Save-Point - RPGMaker XP (RGSS) Engine

Ring Menu Advanced

Thu, 04 Jun 2026 22:37:09 +0000

Ring Menu Advanced
Based upon the
XRXS Ring Menu Implementation
by Kazuki (2007)
Version: 1.1

Introduction

This is another Ring Menu based upon the classic. But with new options:

Features

All editable options now in a single configuration page
Customize the speed, size and options in the ring menu
Able to add and/or remove menu options by configuration
Flexible menu system that can begin with even 0(zero) options shown
Able to execute/switch-to custom scenes or common events
Able to use either the original or Dubealex-styled status window
Able to enable/disable a gold window, either XRXS or Dubealex-styled
Able to enable/disable a Dubealex-styled location window
Set the font, windowskin and opacity levels of most any window
BONUS: The Targeted Return Patch included

Screenshots

Yep... this time

Demo

Here it is! A Box.Com Link

Instructions

Completely within the demo. The header page is dedicated to the instructions while compact instructions are in the configuration page.

FAQ

Believe it or not, I had this working with game windows larger than 640x480.
I also added a nice and sporty little NOT/CANCEL icon. Took like... 2 minutes to sprite?

Compatibility

This will overwrite Scene_Menu. And it uses its own Window_MenuStatus code. So add-ons that affect the window in the main menu showing the party won't function.

Credits and Thanks

My thanks to Kazuki who created the original version of the Ring Menu. Thanks to Dubealex for the Location and Gold windows, and the center forced Menu command display. And thanks to Ouga Zaitou who provided some bitmap content for Kazuki's original work.

Terms and Conditions

Though Kazuki ended support for the Ring Menu nearly two decades ago, actively placing this within an actual 'abandoned' script list, I ask for due credit for myself, Kazuki and Ouga Zaitou.

XRXS_MP 6. Ring Menu Implementation

Tue, 02 Jun 2026 21:09:26 +0000

XRXS_MP 6. Ring Menu Implementation
Version: 1.2
by Kazuki
© 2007
Version 1.0 Release © 2005
Yes, the creator's name is Kazuki, NOT XRXS

Introduction

For years, I've seen the XRXS Ring Menu with additions by Dubealex and others. But never a pure version of the original version. So I decided to use my lycanthropic werewolf hunting skills to track down a pure version untouched by western editors.

And here it is.

Features

Its a RING menu
Contains a compact actor menu when selecting choices like Equip or Skill
Able to customize the icons

Script

I am providing BOTH the original version 1.2 (circa 2007 which Kazuki stated was abandoned) and an English version thanks to an hour's worth of wolfish translation.

Japanese Original Version

Code:
# ▼▲▼ XRXS_MP 6. リングメニュー導入 ver.1.2 ▼▲▼

# by 和希

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

# □ カスタマイズポイント

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

class Window_RingMenu < Window_Base

  STARTUP_FRAMES =  20 # 初期アニメーションのフレーム数

  MOVING_FRAMES  =   5 # リングを回した時のフレーム数

  RING_R         =  64 # リングの半径

  SE_STARTUP  = "056-Right02" # メニューを開いたときに鳴らすSE

  ICON_ITEM   = RPG::Cache.icon("034-Item03")   # 「 アイテム 」メニューのアイコン

  ICON_SKILL  = RPG::Cache.icon("044-Skill01")  # 「　スキル　」メニューのアイコン

  ICON_EQUIP  = RPG::Cache.icon("001-Weapon01") # 「　 装備 　」メニューのアイコン

  ICON_STATUS = RPG::Cache.icon("050-Skill07")  # 「ステータス」メニューのアイコン

  ICON_SAVE   = RPG::Cache.icon("038-Item07")   # 「　セーブ　」メニューのアイコン

  ICON_EXIT   = RPG::Cache.icon("046-Skill03")  # 「　 終了 　」メニューのアイコン

  ICON_DISABLE= RPG::Cache.icon("")             # 使用禁止項目に付くアイコン

  BACKGROUND_COLOR = Color.new(0xcc,0x99,0x33,0x3f)

end

###############################################################################

# リングメニュー導入スクリプト Ver. 1.2

#                 writen by 和希

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

# ▽導入

#   ０．先に XRXL 2. ビットマップ/アイコン描写 を入れて置いてください。

#   １．このスクリプトをMainセクションの上に作った新しいセクションにコピーする

#   ２．Window_RingMenuの上部にある７つの RPG::Cache.icon("") の "" の中に

#       右の説明に書いてあるコマンド用のアイコン名を書く。

#       (一番下の使用禁止は選べないメニューに重ねるアイコンです。

#        こんなのがいいかも→ φ )

#   ３．アイコン設定のすぐ下にある SE_STARTUP = "" の "" の中にメニューを

#       開いたときに鳴らしたいのSEの名前を書く。

# ▽スクリプト触れる人へ

#   とりあえず動く物を目標に作ったものなので(志低いｗ)、座標の調整などが不完全です。

#   より正確にアクターの画面座標を取得する処理を追加したり、アクター一覧の位置を

#   変えたり、文字表示などなどを調整するといい感じに仕上がる気がします。

###############################################################################

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

# ■ Window_RingMenu

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

class Window_RingMenu < Window_Base

  #--------------------------------------------------------------------------

  # ○ クラス定数

  #--------------------------------------------------------------------------

  MODE_START = 1 # スタートアップアニメーション

  MODE_WAIT  = 2 # 待機

  MODE_MOVER = 3 # 時計回り回転アニメーション

  MODE_MOVEL = 4 # 反時計回り回転アニメーション

  #--------------------------------------------------------------------------

  # ○ アクセサ

  #--------------------------------------------------------------------------

  attr_accessor :index

  attr_reader :commands

  #--------------------------------------------------------------------------

  # ● オブジェクト初期化

  #--------------------------------------------------------------------------

  def initialize( center_x, center_y )

    super(-16, -16, 640+32, 480+32)

    self.contents = Bitmap.new(width-32, height-32)

    self.opacity = 0

    self.back_opacity = 0

    s1 = $data_system.words.item

    s2 = $data_system.words.skill

    s3 = $data_system.words.equip

    s4 = "ステータス"

    s5 = "セーブ"

    s6 = "ゲーム終了"

    @commands = [ s1, s2, s3, s4, s5, s6 ]

    @item_max = 6

    @index = 0

    @items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_SAVE, ICON_EXIT ]

    @disabled = [ false, false, false, false, false, false ]

    @cx = center_x

    @cy = center_y

    setup_move_start

    refresh

  end

  #--------------------------------------------------------------------------

  # ● フレーム更新

  #--------------------------------------------------------------------------

  def update

    super

    refresh

  end

  #--------------------------------------------------------------------------

  # ● 画面再描画

  #--------------------------------------------------------------------------

  def refresh

    self.contents.clear

    # 背景描画

    if BACKGROUND_COLOR.alpha > 0

      self.contents.fill_rect(0,0,640,480,BACKGROUND_COLOR)

    end

    # アイコンを描画

    case @mode

    when MODE_START

      refresh_start

    when MODE_WAIT

      refresh_wait

    when MODE_MOVER

      refresh_move(1)

    when MODE_MOVEL

      refresh_move(0)

    end

  end

  #--------------------------------------------------------------------------

  # ○ 画面再描画(初期化時)

  #--------------------------------------------------------------------------

  def refresh_start

    d1 = 2.0 * Math::PI / @item_max

    d2 = 1.0 * Math::PI / STARTUP_FRAMES

    r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES

    for i in 0...@item_max

      j = i - @index

      d = d1 * j + d2 * @steps

      x = @cx + ( r * Math.sin( d ) ).to_i

      y = @cy - ( r * Math.cos( d ) ).to_i

      draw_item(x, y, i)

    end

    @steps -= 1

    if @steps < 1

      @mode = MODE_WAIT

    end

  end

  #--------------------------------------------------------------------------

  # ○ 画面再描画(待機時)

  #--------------------------------------------------------------------------

  def refresh_wait

    d = 2.0 * Math::PI / @item_max

    for i in 0...@item_max

      j = i - @index

      x = @cx + ( RING_R * Math.sin( d * j ) ).to_i

      y = @cy - ( RING_R * Math.cos( d * j ) ).to_i

      draw_item(x, y, i)

    end

  end

  #--------------------------------------------------------------------------

  # ○ 画面再描画(回転時)

  #  mode : 0=反時計回り 1=時計回り

  #--------------------------------------------------------------------------

  def refresh_move( mode )

    d1 = 2.0 * Math::PI / @item_max

    d2 = d1 / MOVING_FRAMES

    d2 *= -1 if mode != 0

    for i in 0...@item_max

      j = i - @index

      d = d1 * j + d2 * @steps

      x = @cx + ( RING_R * Math.sin( d ) ).to_i

      y = @cy - ( RING_R * Math.cos( d ) ).to_i

      draw_item(x, y, i)

    end

    @steps -= 1

    if @steps < 1

      @mode = MODE_WAIT

    end

  end

  #--------------------------------------------------------------------------

  # ● 項目の描画

  #     x : 

  #     y : 

  #     i : 項目番号

  #--------------------------------------------------------------------------

  def draw_item(x, y, i)

    rect = Rect.new(0, 0, @items[i].width, @items[i].height)

    x -= rect.width/2

    y -= rect.height/2

    if @index == i

      self.contents.blt( x, y, @items[i], rect )

      if @disabled[@index]

        self.contents.blt( x, y, ICON_DISABLE, rect )

      end

    else

      self.contents.blt( x, y, @items[i], rect, 128 )

      if @disabled[@index]

        self.contents.blt( x, y, ICON_DISABLE, rect, 128 )

      end

    end

  end

  #--------------------------------------------------------------------------

  # ● 項目を無効にする

  #     index : 項目番号

  #--------------------------------------------------------------------------

  def disable_item(index)

    @disabled[index] = true

  end

  #--------------------------------------------------------------------------

  # ○ 初期化アニメーションの準備

  #--------------------------------------------------------------------------

  def setup_move_start

    @mode = MODE_START

    @steps = STARTUP_FRAMES

    if  SE_STARTUP != nil and SE_STARTUP != ""

      Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)

    end

  end

  #--------------------------------------------------------------------------

  # ○ 回転アニメーションの準備

  #--------------------------------------------------------------------------

  def setup_move_move(mode)

    if mode == MODE_MOVER

      @index -= 1

      @index = @items.size - 1 if @index < 0

    elsif mode == MODE_MOVEL

      @index += 1

      @index = 0 if @index >= @items.size

    else

      return

    end

    @mode = mode

    @steps = MOVING_FRAMES

  end

  #--------------------------------------------------------------------------

  # ○ アニメーション中かどうか

  #--------------------------------------------------------------------------

  def animation?

    return @mode != MODE_WAIT

  end

end

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

# ■ Window_MenuStatus

#------------------------------------------------------------------------------

# 　メニュー画面でパーティメンバーのステータスを表示するウィンドウです。

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

class Window_RingMenuStatus < Window_Selectable

  attr_reader :max_index

  #--------------------------------------------------------------------------

  # ● オブジェクト初期化

  #--------------------------------------------------------------------------

  def initialize

    @max_index = $game_party.actors.size - 1

    h = 32 * (@max_index + 1) + 32

    h = 416 if h > 416

    x = 0

    x = 456 if $game_player.screen_x < 200 + Window_RingMenu::RING_R

    super(x, 64, 184, h)

    self.contents = Bitmap.new(width - 32, $game_party.actors.size * 32)

    refresh

    self.active = false

    self.index = -1

  end

  #--------------------------------------------------------------------------

  # ● リフレッシュ

  #--------------------------------------------------------------------------

  def refresh

    self.contents.clear

    @item_max = $game_party.actors.size

    for i in 0...$game_party.actors.size

      x = 32

      y = 32 * i

      actor = $game_party.actors[i]

      self.contents.draw_facesquare(actor.character_name, actor.character_hue,

                                    4, y + 4 )

      draw_actor_name(actor, x, y)

    end

  end

end

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

# ■ Scene_Menu

#------------------------------------------------------------------------------

# 　メニュー画面の処理を行うクラスです。

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

class Scene_Menu

  #--------------------------------------------------------------------------

  # ● オブジェクト初期化

  #     menu_index : コマンドのカーソル初期位置

  #--------------------------------------------------------------------------

  def initialize(menu_index = 0)

    @menu_index = menu_index

  end

  #--------------------------------------------------------------------------

  # ● メイン処理

  #--------------------------------------------------------------------------

  def main

    # スプライトセットを作成

    @spriteset = Spriteset_Map.new

    # コマンドウィンドウを作成

    bmp = RPG::Cache.character($game_party.actors[0].character_name, 0)

    px = $game_player.screen_x

    py = $game_player.screen_y - bmp.rect.height / 4 / 2

    @command_window = Window_RingMenu.new(px,py)

    @command_window.index = @menu_index

    # パーティ人数が 0 人の場合

    if $game_party.actors.size == 0

      # アイテム、スキル、装備、ステータスを無効化

      @command_window.disable_item(0)

      @command_window.disable_item(1)

      @command_window.disable_item(2)

      @command_window.disable_item(3)

    end

    @command_window.z = 100

    # セーブ禁止の場合

    if $game_system.save_disabled

      # セーブを無効にする

      @command_window.disable_item(4)

    end

    # ステータスウィンドウを作成

    @status_window = Window_RingMenuStatus.new

    @status_window.z = 200

    @status_window.visible = false

    # ヘルプウィンドウを作成

    @help_window = Window_Help.new

    @help_window.set_text(@command_window.commands[@command_window.index],1)

    # トランジション実行

    Graphics.transition

    # メインループ

    loop do

      # ゲーム画面を更新

      Graphics.update

      # 入力情報を更新

      Input.update

      # フレーム更新

      update

      # 画面が切り替わったらループを中断

      if $scene != self

        break

      end

    end

    # トランジション準備

    Graphics.freeze

    # スプライトセットを解放

    @spriteset.dispose

    # ウィンドウを解放

    @command_window.dispose

    @status_window.dispose

    @help_window.dispose

  end

  #--------------------------------------------------------------------------

  # ● フレーム更新

  #--------------------------------------------------------------------------

  def update

    # ウィンドウを更新

    @command_window.update

    @status_window.update

    @help_window.update

    # コマンドウィンドウがアクティブの場合: update_command を呼ぶ

    if @command_window.active

      update_command

      return

    end

    # ステータスウィンドウがアクティブの場合: update_status を呼ぶ

    if @status_window.active

      update_status

      return

    end

  end

  #--------------------------------------------------------------------------

  # ● フレーム更新 (コマンドウィンドウがアクティブの場合)

  #--------------------------------------------------------------------------

  def update_command

    # B ボタンが押された場合

    if Input.trigger?(Input::B)

      # キャンセル SE を演奏

      $game_system.se_play($data_system.cancel_se)

      # マップ画面に切り替え

      $scene = Scene_Map.new

      return

    end

    # C ボタンが押された場合

    if Input.trigger?(Input::C)

      # パーティ人数が 0 人で、セーブ、ゲーム終了以外のコマンドの場合

      if $game_party.actors.size == 0 and @command_window.index < 4

        # ブザー SE を演奏

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      # コマンドウィンドウのカーソル位置で分岐

      case @command_window.index

      when 0  # アイテム

        # 決定  SE を演奏

        $game_system.se_play($data_system.decision_se)

        # アイテム画面に切り替え

        $scene = Scene_Item.new

      when 1  # スキル

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # ステータスウィンドウをアクティブにする

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 2  # 装備

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # ステータスウィンドウをアクティブにする

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 3  # ステータス

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # ステータスウィンドウをアクティブにする

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 4  # セーブ

        # セーブ禁止の場合

        if $game_system.save_disabled

          # ブザー SE を演奏

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # セーブ画面に切り替え

        $scene = Scene_Save.new

      when 5  # ゲーム終了

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # ゲーム終了画面に切り替え

        $scene = Scene_End.new

      end

      return

    end

    # アニメーション中ならカーソルの処理を行わない

    return if @command_window.animation?

    # ↑or← ボタンが押された場合

    if Input.press?(Input::UP) or  Input.press?(Input::LEFT)

      $game_system.se_play($data_system.cursor_se)

      @command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)

      @help_window.set_text(@command_window.commands[@command_window.index],1)

      return

    end

    # ↓or→ ボタンが押された場合

    if Input.press?(Input::DOWN) or  Input.press?(Input::RIGHT)

      $game_system.se_play($data_system.cursor_se)

      @command_window.setup_move_move(Window_RingMenu::MODE_MOVER)

      @help_window.set_text(@command_window.commands[@command_window.index],1)

      return

    end

  end

  #--------------------------------------------------------------------------

  # ● フレーム更新 (ステータスウィンドウがアクティブの場合)

  #--------------------------------------------------------------------------

  def update_status

    # B ボタンが押された場合

    if Input.trigger?(Input::B)

      # キャンセル SE を演奏

      $game_system.se_play($data_system.cancel_se)

      # コマンドウィンドウをアクティブにする

      @command_window.active = true

      @status_window.active = false

      @status_window.visible = false

      @status_window.index = -1

      return

    end

    # C ボタンが押された場合

    if Input.trigger?(Input::C)

      # コマンドウィンドウのカーソル位置で分岐

      case @command_window.index

      when 1  # スキル

        # このアクターの行動制限が 2 以上の場合

        if $game_party.actors[@status_window.index].restriction >= 2

          # ブザー SE を演奏

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # スキル画面に切り替え

        $scene = Scene_Skill.new(@status_window.index)

      when 2  # 装備

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # 装備画面に切り替え

        $scene = Scene_Equip.new(@status_window.index)

      when 3  # ステータス

        # 決定 SE を演奏

        $game_system.se_play($data_system.decision_se)

        # ステータス画面に切り替え

        $scene = Scene_Status.new(@status_window.index)

      end

      return

    end

  end

end

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

# ◇ 外部ライブラリ

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

class Bitmap

# ▼▲▼ XRXL 1. ライン・図形描写 ▼▲▼

  #--------------------------------------------------------------------------

  # ● ライン描画 by 桜雅 在土

  #--------------------------------------------------------------------------

  def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)

    # 描写距離の計算。大きめに直角時の長さ。

    distance = (start_x - end_x).abs + (start_y - end_y).abs

    # 描写開始

    if end_color == start_color

      for i in 1..distance

        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i

        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i

        if width == 1

          self.set_pixel(x, y, start_color) 

        else

          self.fill_rect(x, y, width, width, start_color) 

        end

      end

    else

      for i in 1..distance

        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i

        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i

        r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance

        g = start_color.green * (distance-i)/distance + end_color.green * i/distance

        b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance

        a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance

        if width == 1

          self.set_pixel(x, y, Color.new(r, g, b, a))

        else

          self.fill_rect(x, y, width, width, Color.new(r, g, b, a)) 

        end

      end

    end

  end

  #--------------------------------------------------------------------------

  # ● 多角形の描画(塗りつぶしなし) by 和希

  #    peaks    : 頂点座標の配列 [[x1,y1],[x2,y2],[x3,y3], ... ]

  #    color    : 線の色

  #    width    : 線の幅

  #--------------------------------------------------------------------------

  def draw_polygon(peaks, color, width = 1)

    # 辺(=頂点)の個数分だけ辺を描く

    for i in 0 ... (peaks.size - 1)

      # 頂点同士を線で結ぶ

      draw_line( peaks[i][0], peaks[i][1], peaks[i+1][0], peaks[i+1][1], color, width )

    end

    # 最後の頂点と最初の頂点を結ぶ

    draw_line( peaks[peaks.size - 1][0], peaks[peaks.size - 1][1], peaks[0][0], peaks[0][1], color, width )

  end

# ▼▲▼ XRXL 2. ビットマップ/アイコン描写 ▼▲▼

  #--------------------------------------------------------------------------

  # ● 顔＆枠の描画 by 桜雅 在土

  #     character_name : 描写に利用するキャラクターグラフィック

  #     character_hue  : 描写の色合い

  #     x       : 描画先 X 座標

  #     y       : 描画先 Y 座標

  #--------------------------------------------------------------------------

  def draw_facesquare(character_name, character_hue, x, y, size = 24)

    bitmap = RPG::Cache.character(character_name, character_hue)

    src_rect = Rect.new((bitmap.width/4 - size)/2, 0, size, size)

    self.blt(x, y, bitmap, src_rect)

    self.draw_polygon([[x,y],[x+size,y],[x+size,y+size],[x,y+size]], Color.new(255,255,255,128))

  end

end

English Translated Version

Code:
# ▼▲▼ XRXS_MP 6. Ring Menu Implementation ver.1.2 ▼▲▼

# By Kazuki

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

# □ Customization Points

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

class Window_RingMenu < Window_Base

  STARTUP_FRAMES =  20 # Number of frames in the initial animation

  MOVING_FRAMES  =   5 # The number of frames when rotating the ring

  RING_R         =  64 # Radius of the ring

  SE_STARTUP  = "056-Right02" # The sound effect played when opening the menu

  ICON_ITEM   = RPG::Cache.icon("034-Item03")   # Icons in the "Items" Menu

  ICON_SKILL  = RPG::Cache.icon("044-Skill01")  # Icons in the "Skills" Menu

  ICON_EQUIP  = RPG::Cache.icon("001-Weapon01") # "Equipment" Menu Icon

  ICON_STATUS = RPG::Cache.icon("050-Skill07")  # "Status" Menu Icons

  ICON_SAVE   = RPG::Cache.icon("038-Item07")   # "Save" Menu Icon

  ICON_EXIT   = RPG::Cache.icon("046-Skill03")  # "Exit" Menu Icon

  ICON_DISABLE= RPG::Cache.icon("")             # Icons for Prohibited Items

  BACKGROUND_COLOR = Color.new(0xcc,0x99,0x33,0x3f)

end

###############################################################################

# Ring Menu Implementation Script Ver. 1.2

#                 writen by Kazuki

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

# ▽ Introduction

#   0. Please install "XRXL 2. Bitmap/Icon Rendering" beforehand.

#   1. Copy this script into a new section created above the Main section.

#   2. Inside the double quotas (`""`) of the sevenRPG::Cache.icon("") entries

#      located at the top of `Window_RingMenu, enter the icon for each command.

#      Follow as they are described in the comments to the right.

#      The "Disabled" icon at the bottom is an icon that overlays atop the

#      menu icons that cannot be selected. Recommended is something like: φ

#   3. Inside the "" of the TSE_STARTUP value, place the sound effect that you

#      want to sound when the menu opens

# ▽ For those comfortable working with scripts

#   Since I built this with the sole goal of getting something—anything—up and

#   running (yeah, I set the bar pretty low!), the coordinate alignment and

#   similar details are still incomplete.

#   We added a process to obtain the actor's screen coordinates more accurately,

#   and the position of the actor list.

#   I feel like if you tweak things—such as making changes or adjusting the text

#   display—it will turn out really nicely.

###############################################################################

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

# ■ Window_RingMenu

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

class Window_RingMenu < Window_Base

  #--------------------------------------------------------------------------

  # ○ Class Constants

  #--------------------------------------------------------------------------

  MODE_START = 1 # Startup Animation

  MODE_WAIT  = 2 # Stand By

  MODE_MOVER = 3 # Clockwise Rotation Animation

  MODE_MOVEL = 4 # Counter-clockwise Rotation Animation

  #--------------------------------------------------------------------------

  # ○ Public Instance Variables

  #--------------------------------------------------------------------------

  attr_accessor :index

  attr_reader :commands

  #--------------------------------------------------------------------------

  # ● Object Initialization

  #--------------------------------------------------------------------------

  def initialize( center_x, center_y )

    super(-16, -16, 640+32, 480+32)

    self.contents = Bitmap.new(width-32, height-32)

    self.opacity = 0

    self.back_opacity = 0

    s1 = $data_system.words.item

    s2 = $data_system.words.skill

    s3 = $data_system.words.equip

    s4 = "Status"

    s5 = "Save"

    s6 = "Game Over"

    @commands = [ s1, s2, s3, s4, s5, s6 ]

    @item_max = 6

    @index = 0

    @items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_SAVE, ICON_EXIT ]

    @disabled = [ false, false, false, false, false, false ]

    @cx = center_x

    @cy = center_y

    setup_move_start

    refresh

  end

  #--------------------------------------------------------------------------

  # ● Frame Update

  #--------------------------------------------------------------------------

  def update

    super

    refresh

  end

  #--------------------------------------------------------------------------

  # ● Refresh

  #--------------------------------------------------------------------------

  def refresh

    self.contents.clear

    # Draw background

    if BACKGROUND_COLOR.alpha > 0

      self.contents.fill_rect(0,0,640,480,BACKGROUND_COLOR)

    end

    # Draw Icon

    case @mode

    when MODE_START

      refresh_start

    when MODE_WAIT

      refresh_wait

    when MODE_MOVER

      refresh_move(1)

    when MODE_MOVEL

      refresh_move(0)

    end

  end

  #--------------------------------------------------------------------------

  # ○ Screen redraw (at initialization)

  #--------------------------------------------------------------------------

  def refresh_start

    d1 = 2.0 * Math::PI / @item_max

    d2 = 1.0 * Math::PI / STARTUP_FRAMES

    r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES

    for i in 0...@item_max

      j = i - @index

      d = d1 * j + d2 * @steps

      x = @cx + ( r * Math.sin( d ) ).to_i

      y = @cy - ( r * Math.cos( d ) ).to_i

      draw_item(x, y, i)

    end

    @steps -= 1

    if @steps < 1

      @mode = MODE_WAIT

    end

  end

  #--------------------------------------------------------------------------

  # ○ Screen redraw (standby)

  #--------------------------------------------------------------------------

  def refresh_wait

    d = 2.0 * Math::PI / @item_max

    for i in 0...@item_max

      j = i - @index

      x = @cx + ( RING_R * Math.sin( d * j ) ).to_i

      y = @cy - ( RING_R * Math.cos( d * j ) ).to_i

      draw_item(x, y, i)

    end

  end

  #--------------------------------------------------------------------------

  # ○ Screen Redraw (on Rotation)

  #  mode : 0=Counter-clockwise 1=Clockwise

  #--------------------------------------------------------------------------

  def refresh_move( mode )

    d1 = 2.0 * Math::PI / @item_max

    d2 = d1 / MOVING_FRAMES

    d2 *= -1 if mode != 0

    for i in 0...@item_max

      j = i - @index

      d = d1 * j + d2 * @steps

      x = @cx + ( RING_R * Math.sin( d ) ).to_i

      y = @cy - ( RING_R * Math.cos( d ) ).to_i

      draw_item(x, y, i)

    end

    @steps -= 1

    if @steps < 1

      @mode = MODE_WAIT

    end

  end

  #--------------------------------------------------------------------------

  # ● Draw Item

  #     x : 

  #     y : 

  #     i : Item number

  #--------------------------------------------------------------------------

  def draw_item(x, y, i)

    rect = Rect.new(0, 0, @items[i].width, @items[i].height)

    x -= rect.width/2

    y -= rect.height/2

    if @index == i

      self.contents.blt( x, y, @items[i], rect )

      if @disabled[@index]

        self.contents.blt( x, y, ICON_DISABLE, rect )

      end

    else

      self.contents.blt( x, y, @items[i], rect, 128 )

      if @disabled[@index]

        self.contents.blt( x, y, ICON_DISABLE, rect, 128 )

      end

    end

  end

  #--------------------------------------------------------------------------

  # ● Disable Item

  #     index : Item number

  #--------------------------------------------------------------------------

  def disable_item(index)

    @disabled[index] = true

  end

  #--------------------------------------------------------------------------

  # ○ Preparing the Initialization Animation

  #--------------------------------------------------------------------------

  def setup_move_start

    @mode = MODE_START

    @steps = STARTUP_FRAMES

    if  SE_STARTUP != nil and SE_STARTUP != ""

      Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)

    end

  end

  #--------------------------------------------------------------------------

  # ○ Preparing the Rotation Animation

  #--------------------------------------------------------------------------

  def setup_move_move(mode)

    if mode == MODE_MOVER

      @index -= 1

      @index = @items.size - 1 if @index < 0

    elsif mode == MODE_MOVEL

      @index += 1

      @index = 0 if @index >= @items.size

    else

      return

    end

    @mode = mode

    @steps = MOVING_FRAMES

  end

  #--------------------------------------------------------------------------

  # ○ Whether currently animating

  #--------------------------------------------------------------------------

  def animation?

    return @mode != MODE_WAIT

  end

end

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

# ■ Window_MenuStatus

#------------------------------------------------------------------------------

# 　This window displays party member status on the menu screen.

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

class Window_RingMenuStatus < Window_Selectable

  attr_reader :max_index

  #--------------------------------------------------------------------------

  # ● Object Initialization

  #--------------------------------------------------------------------------

  def initialize

    @max_index = $game_party.actors.size - 1

    h = 32 * (@max_index + 1) + 32

    h = 416 if h > 416

    x = 0

    x = 456 if $game_player.screen_x < 200 + Window_RingMenu::RING_R

    super(x, 64, 184, h)

    self.contents = Bitmap.new(width - 32, $game_party.actors.size * 32)

    refresh

    self.active = false

    self.index = -1

  end

  #--------------------------------------------------------------------------

  # ● Refresh

  #--------------------------------------------------------------------------

  def refresh

    self.contents.clear

    @item_max = $game_party.actors.size

    for i in 0...$game_party.actors.size

      x = 32

      y = 32 * i

      actor = $game_party.actors[i]

      self.contents.draw_facesquare(actor.character_name, actor.character_hue,

                                    4, y + 4 )

      draw_actor_name(actor, x, y)

    end

  end

end

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

# ■ Scene_Menu

#------------------------------------------------------------------------------

# 　This class performs menu screen processing.

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

class Scene_Menu

  #--------------------------------------------------------------------------

  # ● Object Initialization

  #     menu_index : command cursor's initial position

  #--------------------------------------------------------------------------

  def initialize(menu_index = 0)

    @menu_index = menu_index

  end

  #--------------------------------------------------------------------------

  # ● Main Processing

  #--------------------------------------------------------------------------

  def main

    # Make spriteset

    @spriteset = Spriteset_Map.new

    # Make command window

    bmp = RPG::Cache.character($game_party.actors[0].character_name, 0)

    px = $game_player.screen_x

    py = $game_player.screen_y - bmp.rect.height / 4 / 2

    @command_window = Window_RingMenu.new(px,py)

    @command_window.index = @menu_index

    # If number of party members is 0

    if $game_party.actors.size == 0

      # Disable items, skills, equipment, and status

      @command_window.disable_item(0)

      @command_window.disable_item(1)

      @command_window.disable_item(2)

      @command_window.disable_item(3)

    end

    @command_window.z = 100

    # If save is forbidden

    if $game_system.save_disabled

      # Disable save

      @command_window.disable_item(4)

    end

    # Make status window

    @status_window = Window_RingMenuStatus.new

    @status_window.z = 200

    @status_window.visible = false

    # Make help window

    @help_window = Window_Help.new

    @help_window.set_text(@command_window.commands[@command_window.index],1)

    # Execute transition

    Graphics.transition

    # Main loop

    loop do

      # Update game screen

      Graphics.update

      # Update input information

      Input.update

      # Frame update

      update

      # Abort loop if screen is changed

      if $scene != self

        break

      end

    end

    # Prepare for transition

    Graphics.freeze

    # Dispose of spriteset

    @spriteset.dispose

    # Dispose of windows

    @command_window.dispose

    @status_window.dispose

    @help_window.dispose

  end

  #--------------------------------------------------------------------------

  # ● Frame Update

  #--------------------------------------------------------------------------

  def update

    # Update windows

    @command_window.update

    @status_window.update

    @help_window.update

    # If command window is active: call update_command

    if @command_window.active

      update_command

      return

    end

    # If status window is active: call update_status

    if @status_window.active

      update_status

      return

    end

  end

  #--------------------------------------------------------------------------

  # ● Frame Update (when command window is active)

  #--------------------------------------------------------------------------

  def update_command

    # If B button was pressed

    if Input.trigger?(Input::B)

      # Play cancel SE

      $game_system.se_play($data_system.cancel_se)

      # Switch to map screen

      $scene = Scene_Map.new

      return

    end

    # If C button was pressed

    if Input.trigger?(Input::C)

      # If command other than save or end game, and party members = 0

      if $game_party.actors.size == 0 and @command_window.index < 4

        # Play buzzer SE

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      # Branch by command window cursor position

      case @command_window.index

      when 0  # item

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to item screen

        $scene = Scene_Item.new

      when 1  # skill

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Make status window active

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 2  # equipment

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Make status window active

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 3  # status

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Make status window active

        @command_window.active = false

        @status_window.active = true

        @status_window.visible = true

        @status_window.index = 0

      when 4  # save

        # If saving is forbidden

        if $game_system.save_disabled

          # Play buzzer SE

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to save screen

        $scene = Scene_Save.new

      when 5  # Game Over

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to end game screen

        $scene = Scene_End.new

      end

      return

    end

    # Do not process the cursor while an animation is in progress.

    return if @command_window.animation?

    # ↑or← ボタンが押された場合

    if Input.press?(Input::UP) or  Input.press?(Input::LEFT)

      $game_system.se_play($data_system.cursor_se)

      @command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)

      @help_window.set_text(@command_window.commands[@command_window.index],1)

      return

    end

    # If the ↓ or → button is pressed

    if Input.press?(Input::DOWN) or  Input.press?(Input::RIGHT)

      $game_system.se_play($data_system.cursor_se)

      @command_window.setup_move_move(Window_RingMenu::MODE_MOVER)

      @help_window.set_text(@command_window.commands[@command_window.index],1)

      return

    end

  end

  #--------------------------------------------------------------------------

  # ● Frame Update (when status window is active)

  #--------------------------------------------------------------------------

  def update_status

    # If B button was pressed

    if Input.trigger?(Input::B)

      # Play cancel SE

      $game_system.se_play($data_system.cancel_se)

      # Make command window active

      @command_window.active = true

      @status_window.active = false

      @status_window.visible = false

      @status_window.index = -1

      return

    end

    # If C button was pressed

    if Input.trigger?(Input::C)

      # Branch by command window cursor position

      case @command_window.index

      when 1  # skill

        # If this actor's action limit is 2 or more

        if $game_party.actors[@status_window.index].restriction >= 2

          # Play buzzer SE

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to skill screen

        $scene = Scene_Skill.new(@status_window.index)

      when 2  # equipment

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to equipment screen

        $scene = Scene_Equip.new(@status_window.index)

      when 3  # status

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to status screen

        $scene = Scene_Status.new(@status_window.index)

      end

      return

    end

  end

end

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

# ◇ External Libraries

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

class Bitmap

# ▼▲▼ XRXL 1. Line and Shape Drawing ▼▲▼

  #--------------------------------------------------------------------------

  # ● Line drawing by Ouga Zaitou

  #--------------------------------------------------------------------------

  def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)

    # Calculation of rendering distance. A generous estimate for the length at a right angle.

    distance = (start_x - end_x).abs + (start_y - end_y).abs

    # Start drawing

    if end_color == start_color

      for i in 1..distance

        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i

        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i

        if width == 1

          self.set_pixel(x, y, start_color) 

        else

          self.fill_rect(x, y, width, width, start_color) 

        end

      end

    else

      for i in 1..distance

        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i

        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i

        r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance

        g = start_color.green * (distance-i)/distance + end_color.green * i/distance

        b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance

        a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance

        if width == 1

          self.set_pixel(x, y, Color.new(r, g, b, a))

        else

          self.fill_rect(x, y, width, width, Color.new(r, g, b, a)) 

        end

      end

    end

  end

  #--------------------------------------------------------------------------

  # ● Drawing a Polygon (Unfilled) by Kazuki

  #    peaks    : Array of vertex coordinates [[x1,y1],[x2,y2],[x3,y3], ... ]

  #    color    : Line Color

  #    width    : Line width

  #--------------------------------------------------------------------------

  def draw_polygon(peaks, color, width = 1)

    # Draw a number of edges equal to the number of edges (or vertices).

    for i in 0 ... (peaks.size - 1)

      # Connect the vertices with lines.

      draw_line( peaks[i][0], peaks[i][1], peaks[i+1][0], peaks[i+1][1], color, width )

    end

    # Connect the last vertex to the first vertex.

    draw_line( peaks[peaks.size - 1][0], peaks[peaks.size - 1][1], peaks[0][0], peaks[0][1], color, width )

  end

# ▼▲▼ XRXL 2. Bitmap/Icon Rendering ▼▲▼

  #--------------------------------------------------------------------------

  # ● Face and frame drawing by Ouga Zaitou

  #     character_name : Character Graphics Used for Depiction

  #     character_hue  : The Hue of the Character

  #     x       : Drawing Destination X-Coordinate

  #     y       : Drawing Destination Y-Coordinate

  #--------------------------------------------------------------------------

  def draw_facesquare(character_name, character_hue, x, y, size = 24)

    bitmap = RPG::Cache.character(character_name, character_hue)

    src_rect = Rect.new((bitmap.width/4 - size)/2, 0, size, size)

    self.blt(x, y, bitmap, src_rect)

    self.draw_polygon([[x,y],[x+size,y],[x+size,y+size],[x,y+size]], Color.new(255,255,255,128))

  end

end

Instructions

From the translation:

Please install "XRXL 2. Bitmap/Icon Rendering" beforehand.
Copy this script into a new section created above the Main section.
Inside the double quotas (`""`) of the sevenRPG::Cache.icon("") entries located at the top of `Window_RingMenu, enter the icon for each command.
- Follow as they are described in the comments to the right.
- The "Disabled" icon at the bottom is an icon that overlays atop the menu icons that cannot be selected. Recommended is something like: φ
Inside the "" of the TSE_STARTUP value, place the sound effect that you want to sound when the menu opens

Credits and Thanks

Code courtesy of Kazuki, the creator of the XRXS script.
Line Drawing and Face and frame drawing by Ouga Zaitou

MUSIC EFFECT FADE (A small Scriptette)

Fri, 29 May 2026 13:56:51 +0000

MUSIC EFFECT FADE
Version: 1.0

Introduction

This simple scriptette takes advantage of a feature built into RPGMaker's built-in Audio module, and allows you to fade out music events in much the same way as you could background music and ambient sound effects.

Indeed, no alteration was made to the Audio class. However, this feature has always been available despite no method defined for it within the Game_System class nor any map event akin to [Fade Out BGM] or the like.

Script

I can't believe EnterBrain neglected to include THIS

Code:
#==============================================================================

# ** MUSIC EFFECT FADE

#------------------------------------------------------------------------------

#    by DerVVulfman

#    version 1.0

#    05-29-2026 (mm/dd/yyyy)

#    RGSS / RPGMaker XP

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

#

#  INTRODUCTION:

#

#  This simple scriptette takes advantage of a feature built into RPGMaker's

#  built-in Audio module,  and allows you to  fade out music events  in much

#  the same way as you could background music and ambient sound effects.

#

#  Indeed, no alteration was made to the Audio class.  However, this feature

#  has always  been available  despite no method  defined for it  within the

#  Game_System class nor any map event akin to [Fade Out BGM] or the like.

#

#  To use upon an already playing ME/Music Event, run either script call:

#

#        * $game_system.me_fade(time)

#        * me_fade(time)

#          - time : duration in seconds

#

#        EX: $game_system.me_fade(0.5)

#          - Fades out the currently playing ME in 1/2 a second

#

#  This is to be executed after music events are already playing, and inten-

#  def for music events that are considered longer than normal.  Such longer

#  music events would be akin to victory music from a Final Fantasy game.

#

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

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

# ** Game_System

#------------------------------------------------------------------------------

#  This class handles data surrounding the system. Backround music, etc.

#  is managed here as well. Refer to "$game_system" for the instance of 

#  this class.

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

class Game_System

  #--------------------------------------------------------------------------

  # * Fade Out Music Effect

  #     time : fade-out time (in seconds)

  #--------------------------------------------------------------------------

  def me_fade(time)

    Audio.me_fade(time * 1000)

  end

end

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

# ** Interpreter

#------------------------------------------------------------------------------

#  This interpreter runs event commands. This class is used within the

#  Game_System class and the Game_Event class.

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

class Interpreter

  #--------------------------------------------------------------------------

  # * Fade Out Music Effect

  #     time : fade-out time (in seconds)

  #--------------------------------------------------------------------------

  def me_fade(time)

    $game_system.me_fade(time)

  end

end

Instructions

Just paste this below Scene_Debug and above Main. And use either script command noted in the script to fade out the music event effect.

Compatibility

ABSOLUTELY NO INCOMPATABILITIES! I don't think anyone noticed this.

Author's Notes

WHY HAD NO ONE NOTICED THIS!?!?

Terms and Conditions

Yell at Enterbrainless for not including this in the base system even though I did no alteration to the Audio class itself. THEY HAD THIS FEATURE POSSIBLE ALL THESE YEARS!!!

Reserve Party Tools

Wed, 27 May 2026 18:01:15 +0000

Reserve Party Tools
Original Version by RPG Advocate 4/12/2005
Edit and repairs by DerVVulfman

Introduction

This script enables support for a "reserve" party of arbitrary size. These characters don't fight in battle. You are able to remove party members and place them within the reserves by use of a new menu designed in the system. And adding new party members (with "Change Party Member") while the party is full will add them to the reserves.

The original version required rewrites everywhere and expected the end-user to perform direct edits to the default scripts. This version fixes some errors and oversights . And while still containing some direct alterations of default scripts, has those edited areas clearly marked for reference.

Script

The Script

Code:
#==============================================================================

# Reserve Party Tools

#------------------------------------------------------------------------------

# by RPG Advocate 4/12/2005

# Edit and repairs by DerVVulfman 6/27/2026

# RGSS / RPGMaker XP

#

#------------------------------------------------------------------------------

#

# THE RESERVE PARTY MENU

#

# This script enables support  for a "reserve" party of arbitrary size.  These

# characters don't fight in battle. If you want to give the player the ability

# to switch characters between the party and reserve party,  use either script

# call shown below:

#

# *  $scene = Scene_PartyChange.new(value)

# *  change_party(value)

#

# The 'value' represents  the maximun number of members you want in the party,

# and can be left empty if using the default party size of '4'. You may set it

# the range from 0-4, with 0 indicating full default party size of '4'. Values

# beyond that range are invalid.

#

# *  $scene = Scene_PartyChange.new

# *  change_party

#

#

#------------------------------------------------------------------------------

#

# RESERVIST BATTLE EXPERIENCE

#

# By default, inactive party members gain experience at the same rate as active

# members. To change this,  edit the EXP_PERCENT constant  in the RPGAdvReserve

# module to the percentage of experience you want the inactive party to gain.

#

#

#------------------------------------------------------------------------------

#

# REQUIRED / PERMANENT PARTY MEMBERS

#

# This script supports required party members, actors that have been classified

# as necessary within the party  and cannot be removed.  To make a party member

# required or remove its required status, you may use either script calls:

#

# *  $game_party.actors[actor_id].required = true/false

# *  required_actor(actor_id, true/false)

#

# Both calls requests you  to set a value of true,  or false in order to remove

# the required status.  And within the Change Member menu,  these party members

# will appear with a predefined color in their names, default to Goldenrod.

#

# You should only make a character already in the party required. 

#

# Making a reserve member 'required' will not work.

#

#

#------------------------------------------------------------------------------

#

# CHANGING PARTY MEMBERS

#

# This script changes how the "Change Party Members" event command works.

#

# If you try to add a charater to the party when the party is full, that char-

# acter will automatically be added to the reserve party.  And if you remove a

# party member, that character will be removed if they are in either the party

# or the reserve party. However, it only recognizes a 4-party system when this

# is applied, and does not recognize alternate party sizes.

#

#

#------------------------------------------------------------------------------

#

# SCRIPT CALLS

#

# Initially,  the only script calls noted were lenghty  and direct commands to

# the Game_Party class  or direct calls  to $scene itself.  Other script calls

# were possible but not given. Here, we view all relevant script calls showing

# both original and newer quick commands found in the Interpreter class:

#

#   The Menu Command

#   ----------------

#   Used to bring up the actual Party/Reservist changing menu

#     *  $scene = Scene_ChangeParty.new(max_size)

#     *  change_party(max_size)

#

#   Set Actor Required Status

#   -------------------------

#   Used to define an in-party  (not a reservist member)  as a fixed member of

#   the current party.  The 'actor_id' value is from the database ID.  And the

#   'flag' value is either true or false.

#     *  $game_party.actors[actor_id].required = flag

#     *  required_actor(actor_id, flag)

#

#   Swap Actors by database ID

#   --------------------------

#   Assuming there is a system  tracking what actors  (by database ID)  are in

#   both the party and reserve party, this command lets you exchange one actor

#   from the party with one from the reserves.

#   IT DOES NOT RECOGNIZE THE 'REQUIRED" ACTOR STATUS

#     *  $game_party.swap_by_id(party_actor_id, reserve_actor_id)

#     *  swap_by_id(party_actor_id, reserve_actor_id)

#

#   Transfer Reservist to the Party by ID

#   -------------------------------------

#   Assuming there is a system  tracking what actors  (by database ID)  are in

#   the reserve party, this command lets you remove the actor from the reserve

#   party and places it into the main/active party.

#     *  $game_party.transfer_to_party_by_id(reserve_actor_id)

#     *  transfer_to_party_by_id(reserve_actor_id)

#

#   Transfer Party Member to the Reserves by ID

#   -------------------------------------------

#   Assuming there is a system  tracking what actors  (by database ID)  are in

#   main/active party,  this command lets you remove the actor  from the party

#   and places it into the reserves.

#   IT DOES NOT RECOGNIZE THE 'REQUIRED" ACTOR STATUS

#     *  $game_party.transfer_to_reserve_by_id(party_actor_id)

#     *  transfer_to_reserve_by_id(party_actor_id)

#

#

#------------------------------------------------------------------------------

#

# CHANGES FROM THE ORIGINAL

#

# This revision creates an RPGAdvReserve module where configuration values are

# found.  Originally, the script had only two values to adjust, but these were

# actively situated  within the script itself.  And this would  require you to

# navigate through the script to find those values. The creation of the module

# should make it easier to define what settings are desired.

#

# The system had values that were hardwired into the original script, be these

# the color settings for Required Actor displays  or the descriptive texts and

# warning notices within.  These have also been  migrated to the configuration

# section so you have no need to search within the scripts.

#

# Repairs had to be performed.  You could previously exit  the above described

# Party Changing menu  with a party containing no members at all.  This effec-

# tively would prevent  the game to continue.  The configuration section has a

# switch to permit this, but not recommended.

#

# Likewise, there were issues  with identifying required and reservist members

# in the change party menu. RPG Advorate indeed created the Goldenrod Required

# member color, but never applied its use in the menu. This has been corrected

# while also creating a like color for reserve members appearing in the menus.

#

#

#------------------------------------------------------------------------------

#

# COMPATABILITY / SCRIPT ATTACHED CODE AND REWRITES

#

# This script, when initially released, was not designed to paste the contents

# in place,  but instead instructed you  to directly edit the default scripts.

# At the time of release,  there was little knowledge  of the 'alias' property

# which would allow the insertion of new code into methods. And this rework of

# his script takes advantage of the alias technique where it was possible.

# the default scripts. It was not released as a script to insert into 

#

# Not all sections were able to benefit of the alias technique,  those methods

# still requiring their code rewritten/overwritten. However, said methods have

# the rewritten sections identified.

#

# New Script Content:

#  * RPGAdvReserve          : (New) Used to hold configuration values

#  * Game_Party             : (Used by ChangeParty) Methods made to swap members

#  * Window_Base            : (Used by ChangeParty) Makes color identified names

#  * Window_ChangeMain      : (Used by ChangeParty) Draws the current party

#  * Window_ChangeReserve   : (Used by ChangeParty) Draws the reserve party

#  * Window_PartyChangeInfo : (Used by ChangeParty) Draws recommended party size

#  * Interpreter            : Shortcut script calls made for the system

#  * Scene_ChangeParty      : Engine that switches party and reservists around

#

# Aliased Script Content:

#  * Game_Actor             : Adds the required member status variable

#  * Game_Party             : Makes the reserve array & alters add/remove member

#

# Rewritten Script Content:

#  * Scene_Menu             : update_status edited for reservist restrictions

#  * Scene_Skill            : main method altered to allow access to reserves

#  * Scene_Equip            : main method altered to allow access to reserves

#  * Scene_Battle           : start_phase5 altered to allow reserve EXP gains

#

# All scripts that are rewrites of the default scripts have their new code in

# defined areas  beginning with  either "Beginning of Replaced Code"  or with

# "Beginning of Inserted Code",  and ending  with a like commented statement.

# In many cases, the original code is still available,  but commented out for

# end-user recognition.

#

#

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

module RPGAdvReserve

  # FEATURE SETTINGS

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

  # If Reserve members appear in the menu status screen.

    MENU_STATUS = true

  # The percent of Exp reserve members get compared to active.

    EXP_PERCENT = 100

  # (NEW) Allow party to be emptied by Party Changer (not recommended)

  # Original did not have a block to prevent emptying ... what a flaw!

    PERMIT_EMPTY = true

  # COLOR SETTINGS

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

  # Color of actor name when required to be in party.

  # Default 216,150,20,255:  Goldenrod

    COLOR_REQUIRED = Color.new(216, 150, 20, 255)

  # Color of actor name in menu status if a reserve member.

  # Default 152, 181, 100, 255:  Olive

    COLOR_RESERVIST = Color.new(152, 181, 100, 255)

  # ACTOR WARNING MESSAGES

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

  # A carte-blanch error if actor IDs values given are invalid

    ID_INVALID          = "ID given is invalid."

  # Define the text used to show at least one invalid party or reservist ID.

    SWAP_Invalid        = "Cannot swap members. One or both are invalid."

  # Define the text used to show the actor ID is not in the reservist party.

    TO_PARTY_Invalid    = "Warning: Character is not in the reserve party."

  # Define the text used to show the party is full.

    TO_PARTY_Full       = "Warning: Main party is full."

  # Define the text used to show the actor ID is not in the current party.

    TO_RESERVE_Invalid  = "Warning: Character is not in the main party."

  # PARTY CHANGER MESSAGES

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

  # Single-line text used to request a party be formed to default.

    INFO_Request1       = "Please form a party."

  # Dual-line text used to request a custom sized party. Must include {size}.

    INFO_Request2a      = "Please form a party"

    INFO_Request2b      = "of up to {size} members."

  # Warning to note max size setting is invalid.

    SIZE_Invalid        = "Warning: Invalid max size for party."

  # Text used to indicate empty position in party

    EMPTY               = "- Empty -"

    DISALLOWED          = "- Disallowed -"

end

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

# ** Game_Actor

#------------------------------------------------------------------------------

#  This class handles the actor. It's used within the Game_Actors class

#  ($game_actors) and refers to the Game_Party class ($game_party).

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

class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------

  # * Public Instance Variables

  #--------------------------------------------------------------------------

  attr_accessor :required                 # required party member flag

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias rpgadv_reserve_g_actor_setup setup

  #--------------------------------------------------------------------------

  # * Setup

  #     actor_id : actor ID

  #--------------------------------------------------------------------------

  def setup(actor_id)

    #

    rpgadv_reserve_g_actor_setup(actor_id)            # Run the original method

    @required = false                                 # Add the additional flag

    #

  end

end

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

# ** Game_Party

#------------------------------------------------------------------------------

#  This class handles the party. It includes information on amount of gold

#  and items. Refer to "$game_party" for the instance of this class.

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

class Game_Party

  #--------------------------------------------------------------------------

  # * Public Instance Variables

  #--------------------------------------------------------------------------

  attr_accessor :reserve_actors           # reserve actors array

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias rpgadv_reserve_g_party_init initialize

  alias rpgadv_reserve_g_party_setup_add add_actor

  alias rpgadv_reserve_g_party_setup_remove remove_actor

  #--------------------------------------------------------------------------

  # * Object Initialization

  #--------------------------------------------------------------------------

  def initialize

    #

    rpgadv_reserve_g_party_init                     # Run the original method

    @reserve_actors = []                            # Add the additional array

    #

  end

  #--------------------------------------------------------------------------

  # * Add an Actor

  #     actor_id : actor ID

  #--------------------------------------------------------------------------

  def add_actor(actor_id)

    #

    actor = $game_actors[actor_id]                  # Get actor  

    if @actors.size >= 4                            # If the party is full

      if not @actors.include?(actor)                # If actor not in party  

        if not @reserve_actors.include?(actor)      # If actor not in reserve

          @reserve_actors.push(actor)               # Add actor to reserve

          return                                    # And exit method

        end

      end

    end

    #

    rpgadv_reserve_g_party_setup_add(actor_id)      # Run the original method

    #

  end

  #--------------------------------------------------------------------------

  # * Remove Actor

  #     actor_id : actor ID

  #--------------------------------------------------------------------------

  def remove_actor(actor_id)

    #

    @reserve_actors.delete($game_actors[actor_id])  # Delete actor from reserve

    rpgadv_reserve_g_party_setup_remove(actor_id)   # Run the original method

    #

  end

  #--------------------------------------------------------------------------

  # * Swap Actors

  #     actor1 : actor

  #     actor2 : actor

  #--------------------------------------------------------------------------

  def swap(actor1, actor2)

    #

    error = false                                   # Set no error

    #

    if not @actors.include?(actor1)                 # If actor1 not in party

      error = true                                  # Set error 

    end

    if not @reserve_actors.include?(actor2)         # If actor2 not in reserve

      error = true                                  # Set error 

    end

    if error                                        # If in error

      print(RPGAdvReserve::SWAP_Invalid)            # Display error message

      return                                        # And exit method

    end

    #

    @reserve_actors.push(actor1)                    # Add party actor to reserve

    @actors.delete(actor1)                          # Delete actor from party

    add_actor(actor2.id)                            # Add reserve actor to party

    @reserve_actors.delete(actor2)                  # Delete from reserve party

    #

  end

  #--------------------------------------------------------------------------

  # * Transfer to Party

  #     actor : actor

  #--------------------------------------------------------------------------

  def transfer_to_party(actor)

    #

    if not @reserve_actors.include?(actor)          # If actor not in reserve

      print(RPGAdvReserve::TO_PARTY_Invalid)        # Display error message

      return                                        # And exit method

    end

    #

    if @actors.size == 4                            # If party is full

      print(RPGAdvReserve::TO_PARTY_Full)           # Display error message

      return                                        # And exit method

    end

    #

    add_actor(actor.id)                             # Add reservist to party

    @reserve_actors.delete(actor)                   # Delete from reserve party

    #

  end

  #--------------------------------------------------------------------------

  # * Transfer to Reserve

  #     actor : actor

  #--------------------------------------------------------------------------

  def transfer_to_reserve(actor)

    #

    if not @actors.include?(actor)                  # If actor not in party

      print(RPGAdvReserve::TO_RESERVE_Invalid)      # Display error message

      return                                        # And exit method

    end

    #

    remove_actor(actor.id)                          # Delete actor from party

    @reserve_actors.push(actor)                     # Add party actor to reserve

    #

  end

  #--------------------------------------------------------------------------

  # * Swap Actors by ID

  #     party_actor_id   : actor ID

  #     reserve_actor_id : actor ID

  #--------------------------------------------------------------------------

  def swap_by_id(party_actor_id, reserve_actor_id)

    #

    return unless valid_id?(party_actor_id)         # Exit if invalid actor ID

    return unless valid_id?(reserve_actor_id)       # Exit if invalid reserve ID

    #

    actor1 = $game_actors[party_actor_id]           # Get party member actor

    actor2 = $game_actors[reserve_actor_id]         # Get reserve member actor

    #

    swap(actor1, actor2)                            # Swap the actors

    #

  end

  #--------------------------------------------------------------------------

  # * Transfer to Party by ID

  #     reserve_actor : actor ID

  #--------------------------------------------------------------------------

  def transfer_to_party_by_id(reserve_actor_id)

    #

    return unless valid_id?(reserve_actor_id)       # Exit if invalid reserve ID

    actor = $game_actors[reserve_actor_id]          # Get reserve member actor

    transfer_to_party(actor)                        # Transfer actor to party

    #

  end

  #--------------------------------------------------------------------------

  # * Transfer to Reserve by ID

  #     main_party_actor : actor ID

  #--------------------------------------------------------------------------

  def transfer_to_reserve_by_id(party_actor_id)

    #

    return unless valid_id?(party_actor_id)         # Exit if invalid actor ID

    actor = $game_actors[party_actor_id]            # Get party member actor

    transfer_to_reserve(actor)                      # Transfer actor to reserve

    #

  end

  #--------------------------------------------------------------------------

  # * Test for valid values above 0

  #     actor_id : actor ID

  #--------------------------------------------------------------------------

  def valid_id?(actor_id)

    #

    test = true                                       # Assume passes

    test = false if actor_id.nil?                     # Fail if nil

    test = false unless actor_id.is_a?(Numeric)       # Fail if not numeric

    test = false if actor_id <= 0                     # Exit if invalid value

    return true  if test                              # Exit true if passes

    print(RPGAdvReserve::ID_INVALID)                  # Render ID alert

    return false                                      # Exit method false

    #

  end

end

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

# ** Window_Base

#------------------------------------------------------------------------------

#  This class is for all in-game windows.

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

class Window_Base < Window

  #--------------------------------------------------------------------------

  # * Required Color (Goldenrod)

  #--------------------------------------------------------------------------

  def required_color

    return RPGAdvReserve::COLOR_REQUIRED

  end

  #--------------------------------------------------------------------------

  # * Required Color (Olive)

  #--------------------------------------------------------------------------

  def reservist_color

    return RPGAdvReserve::COLOR_RESERVIST

  end

  #--------------------------------------------------------------------------

  # * Draw Required Name

  #     actor : actor

  #     x     : draw spot x-coordinate

  #     y     : draw spot y-coordinate

  #--------------------------------------------------------------------------

  def draw_actor_required(actor, x, y)

    self.contents.font.color = required_color

    self.contents.draw_text(x, y, 120, 32, actor.name)

  end  

  #--------------------------------------------------------------------------

  # * Draw Reservist Name

  #     actor : actor

  #     x     : draw spot x-coordinate

  #     y     : draw spot y-coordinate

  #--------------------------------------------------------------------------

  def draw_actor_reservist(actor, x, y)

    self.contents.font.color = reservist_color

    self.contents.draw_text(x, y, 120, 32, actor.name)

  end

end

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

# ** Window_MenuStatus

#------------------------------------------------------------------------------

#  This window displays party member status on the menu screen.

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

class Window_MenuStatus < Window_Selectable

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh

    #

    self.contents.dispose                             # Erase contents at start

    #

    @item_max = $game_party.actors.size               # Set max size by party

    if RPGAdvReserve::MENU_STATUS                     # If Switch engaged  

      @item_max += $game_party.reserve_actors.size    # Add reserves to size

    end

    #

    wd    = width - 32                                # Set width

    ht    = @item_max * 120 - 32                      # Set height by max size

    self.contents = Bitmap.new(wd, ht)                # Set contents

    self.contents.clear                               # And make contents clear

    #

    actor_array = []                                  # create actor array

    for actor in $game_party.actors                   # Cycle through party

      actor_array.push(actor)                         # and push actors in array

    end

    if RPGAdvReserve::MENU_STATUS                     # If Switch engaged

      for actor in $game_party.reserve_actors         # Cycle through reserves

        actor_array.push(actor)                       # and push actors in array

      end

    end

    party_idx_max = $game_party.actors.size - 1       # Get last ID for party

    #

    for id in 0...@item_max                           # Cycle total actor size

      x = 64                                          # Set X Coordinate

      y = id * 116                                    # Set Y coord by counter

      actor = actor_array[id]                         # Get actor by counter

      #

      draw_actor_graphic(actor, x - 40, y + 80)       # Draw character

      draw_actor_name(actor, x, y)                    # Draw name

      if id > party_idx_max                           # If counter past party

        draw_actor_reservist(actor, x, y)             # Draw reservist name

      end

      draw_actor_class(actor, x + 144, y)             # Draw class

      draw_actor_level(actor, x, y + 32)              # Draw level

      draw_actor_state(actor, x + 90, y + 32)         # Draw state

      draw_actor_exp(actor, x, y + 64)                # Draw exp

      draw_actor_hp(actor, x + 236, y + 32)           # Draw hp

      draw_actor_sp(actor, x + 236, y + 64)           # Draw sp

      #

    end

    #

  end  

  #--------------------------------------------------------------------------

  # * Cursor Rectangle Update

  #--------------------------------------------------------------------------

  def update_cursor_rect

    #

    if @index < 0                                     # If no valid index 

      self.cursor_rect.empty                          # Remove cursor

    else                                              # Otherwise

      y   = @index * 116 - self.oy                    # Get y-position

      wd  = self.width - 32                           # Get width 

      self.cursor_rect.set(0, y, wd, 96)              # And set cursor dimension

    end

    if self.cursor_rect.y < 0                         # If position less than 0

      self.oy -= 116                                  # Reduce origin 

      refresh                                         # Refresh menu contents

      update_cursor_rect                              # And redraw cursor

    end

    if self.cursor_rect.y > 348                       # If position over 348

      self.oy += 116                                  # Increase origin

      refresh                                         # Refresh menu contents

      update_cursor_rect                              # And redraw cursor

    end

    #

  end

end

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

# ** Window_ChangeMain

#------------------------------------------------------------------------------

#  This window displays the current party members in the Party Changer scene

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

class Window_ChangeMain < Window_Selectable

  #--------------------------------------------------------------------------

  # * Object Initialization

  #--------------------------------------------------------------------------

  def initialize(max_size=3)

    #

    super(0, 0, 320, 480)

    self.contents = Bitmap.new(width - 32, height - 32)

    refresh

    self.active = false

    self.index  = -1

    @max_size   = max_size

    #

  end

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh

    #

    self.contents.clear                               # Make contents clear

    @item_max = 4                                     # Set max  

    for idx in 0..3                                   # Cycle through party max

      x = 64                                          # Set text x coordinates

      y = idx * 116                                   # Set Y coords by counter

      if $game_party.actors[idx] != nil               # If a valid actor

        actor = $game_party.actors[idx]               # Set actor

      else                                            # Otherwise

        if idx > @max_size                            # If space above max size

          text = RPGAdvReserve::DISALLOWED            # Set disallowed text

        else                                          # Otherwise  

          text = RPGAdvReserve::EMPTY                 # Set empty space text

        end

        self.contents.draw_text(0,y+32,288,32,text,1) # Display the text

        next                                          # And skip to next actor

      end

      draw_actor_graphic(actor, x - 40, y + 80)       # Draw Graphic

      draw_actor_name(actor, x, y)                    # Draw name

      if actor.required == true                       # If a required actor

        draw_actor_required(actor, x, y)              # Redraw Required name

      end

      draw_actor_level(actor, x + 160, y)             # Draw Level

      draw_actor_hp(actor, x, y + 32)                 # Draw HP

      draw_actor_sp(actor, x, y + 64)                 # Draw SP

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Cursor Rectangle Update

  #--------------------------------------------------------------------------

  def update_cursor_rect

    #

    if @index < 0                                     # If no valid index 

      self.cursor_rect.empty                          # Remove cursor

    else                                              # Otherwise

      y   = @index * 116                              # Get y-position

      wd  = self.width - 32                           # Get width 

      self.cursor_rect.set(0, y, wd, 96)              # And set cursor dimension

    end

    #

  end

end

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

# ** Window_ChangeReserve

#------------------------------------------------------------------------------

#  This window displays the reserve party members in the Party Changer scene

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

class Window_ChangeReserve < Window_Selectable

  #--------------------------------------------------------------------------

  # * Object Initialization

  #--------------------------------------------------------------------------

  def initialize

    #

    super(320, 0, 320, 360)

    self.contents = Bitmap.new(width - 32, height - 32)

    refresh

    self.active = false

    self.index = -1

    #

  end

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh

    #

    @item_max = $game_party.reserve_actors.size + 1   # Get reservist party max

    size  = 96 + @item_max * 96 - 32                  # Set reservist area size

    size  = 328 if size < 328                         # Limit size to window

    #

    self.contents.dispose                             # Erase contents area

    self.contents = Bitmap.new(width - 32, size)      # Set contents

    self.contents.clear                               # And make contents clear

    #

    for idx in 0...$game_party.reserve_actors.size    # Cycle through reservists

      x = 64                                          # Set text x coordinates

      y = idx * 116                                   # Set Y coords by counter

      actor = $game_party.reserve_actors[idx]         # Get reservist actor

      draw_actor_graphic(actor, x - 40, y + 80)       # Draw character

      draw_actor_name(actor, x, y)                    # Draw name

      draw_actor_level(actor, x + 160, y)             # Draw Level

      draw_actor_hp(actor, x, y + 32)                 # Draw HP

      draw_actor_sp(actor, x, y + 64)                 # Draw SP

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Cursor Rectangle Update

  #--------------------------------------------------------------------------

  def update_cursor_rect

    #

    if @index < 0                                     # If no valid index 

      self.cursor_rect.empty                          # Remove cursor

    else                                              # Otherwise

      y   = @index * 116 - self.oy                    # Get y-position

      wd  = self.width - 32                           # Get width 

      self.cursor_rect.set(0, y, wd, 96)              # And set cursor dimension

    end

    if self.cursor_rect.y < 0                         # If position less than 0

      self.oy -= 116                                  # Reduce origin 

      refresh                                         # Refresh menu contents

      update_cursor_rect                              # And redraw cursor

    end

    if self.cursor_rect.y > 232                       # If position over 232

      self.oy += 116                                  # Increase origin

      refresh                                         # Refresh menu contents

      update_cursor_rect                              # And redraw cursor

    end

    #

  end

end

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

# ** Window_PartyChangeInfo

#------------------------------------------------------------------------------

#  This window displays help information in the Party Changer scene

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

class Window_PartyChangeInfo < Window_Base

  #--------------------------------------------------------------------------

  # * Public Instance Variables

  #--------------------------------------------------------------------------

  attr_reader   :max_size                 # maximum party size

  #--------------------------------------------------------------------------

  # * Object Initialization

  #--------------------------------------------------------------------------

  def initialize(max_size)

    #

    super(320, 360, 320, 120)

    self.contents = Bitmap.new(width - 32, height - 32)

    @max_size = max_size

    refresh

    #

  end

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh

    #

    self.contents.clear                               # And make contents clear

    text1 = RPGAdvReserve::INFO_Request1              # Get Full Party Size note

    text2 = RPGAdvReserve::INFO_Request2a             # Get 1st Set party note

    tempt = RPGAdvReserve::INFO_Request2b             # Get 2nd Set party note

    text3 = tempt.gsub(/{size}/) {(@max_size.to_s) }  # Replace string with size

    #

    if @max_size == 0                                 # If max size default

      self.contents.draw_text(4, 0, 240, 32, text1)   # Show full party note

    end

    if @max_size > 0                                  # If alternate size

      self.contents.draw_text(4, 0, 240, 32, text2)   # Show 1st party note

      self.contents.draw_text(4, 32, 240, 32, text3)  # Show 2nd party note

    end

    #

  end

end

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

# ** Interpreter

#------------------------------------------------------------------------------

#  This interpreter runs event commands. This class is used within the

#  Game_System class and the Game_Event class.

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

class Interpreter

  #--------------------------------------------------------------------------

  # * Swap Actors by database ID

  #     party_actor_id   : actor ID

  #     reserve_actor_id : actor ID

  #--------------------------------------------------------------------------

  def swap_by_id(party_actor_id=1, reserve_actor_id=1)

    $game_party.swap_by_id(party_actor_id, reserve_actor_id)

  end

  #--------------------------------------------------------------------------

  # * Transfer to Party by database ID

  #     reserve_actor_id : actor ID

  #--------------------------------------------------------------------------

  def transfer_to_party_by_id(reserve_actor_id=1)

    $game_party.transfer_to_party_by_id(reserve_actor_id)

  end

  #--------------------------------------------------------------------------

  # * Transfer to Reserve by database ID

  #     party_actor_id : actor ID

  #--------------------------------------------------------------------------

  def transfer_to_reserve_by_id(party_actor_id=1)

    $game_party.transfer_to_reserve_by_id(party_actor_id)

  end

  #--------------------------------------------------------------------------

  # * Set required actor flag

  #     actor_id : actor ID

  #     flag     : boolean value (true/false)

  #--------------------------------------------------------------------------

  def required_actor(actor_id=0, flag=true)

    return if actor_id.nil?                           # Exit if nil

    return unless value.is_a?(Numeric)                # Exit if not numeric

    return if actor_id <= 0                           # Exit if invalid value

    return if $game_party.actors[actor_id] == nil     # Exit if no actor

    return unless (flag == true || flag == false)     # Exit if not boolean

    $game_party.actors[actor_id].required = flag      # Apply the flag

  end

  #--------------------------------------------------------------------------

  # * Party Changer Menu

  #     max_size : party size maximum

  #--------------------------------------------------------------------------

  def change_party(max_size=0)

    $scene = Scene_ChangeParty.new(max_size)

  end

end

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

# ** Scene_Menu

#------------------------------------------------------------------------------

#  This class performs menu screen processing.

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

class Scene_Menu

  #--------------------------------------------------------------------------

  # * Frame Update (when status window is active)

  #--------------------------------------------------------------------------

  def update_status

    #

    # If B button was pressed

    if Input.trigger?(Input::B)

      # Play cancel SE

      $game_system.se_play($data_system.cancel_se)

      # Make command window active

      @command_window.active = true

      @status_window.active = false

      @status_window.index = -1

      return

    end

    # If C button was pressed

    if Input.trigger?(Input::C)

      # Branch by command window cursor position

      case @command_window.index

      when 1  # skill

        ## If this actor's action limit is 2 or more

        #if $game_party.actors[@status_window.index].restriction >= 2

        #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

        # * Beginning of Replaced Code

        #--------------------------------------------------------------------

        # Check actor restriction if index points to active party member

        if @status_window.index < $game_party.actors.size

          check_actor = $game_party.actors[@status_window.index]

        else

          # Or check actor restriction for reserve party member

          size = $game_party.actors.size

          check_actor = $game_party.reserve_actors[@status_window.index - size]

        end

        # If this actor's action limit is 2 or more

        if check_actor.restriction >= 2

        #--------------------------------------------------------------------

        # * Replaced Code End

        #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

          # Play buzzer SE

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to skill screen

        $scene = Scene_Skill.new(@status_window.index)

      when 2  # equipment

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to equipment screen

        $scene = Scene_Equip.new(@status_window.index)

      when 3  # status

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Switch to status screen

        $scene = Scene_Status.new(@status_window.index)

      end

      return

    end

    #

  end

end

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

# ** Scene_Skill

#------------------------------------------------------------------------------

#  This class performs skill screen processing.

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

class Scene_Skill

  #--------------------------------------------------------------------------

  # * Main Processing

  #--------------------------------------------------------------------------

  def main  

    #

    ## Get actor

    #@actor = $game_party.actors[@actor_index]

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    # * Beginning of Replaced Code

    #------------------------------------------------------------------------

    # If actor index within party size

    if @actor_index < $game_party.actors.size

      # Get actor from party

      @actor = $game_party.actors[@actor_index]

    else

      # Otherwise get actor from reserve party

      idx = @actor_index - $game_party.actors.size

      @actor = $game_party.reserve_actors[idx]

    end

    #------------------------------------------------------------------------

    # * Replaced Code End

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    #

    # Make help window, status window, and skill window

    @help_window = Window_Help.new

    @status_window = Window_SkillStatus.new(@actor)

    @skill_window = Window_Skill.new(@actor)

    # Associate help window

    @skill_window.help_window = @help_window

    # Make target window (set to invisible / inactive)

    @target_window = Window_Target.new

    @target_window.visible = false

    @target_window.active = false

    # Execute transition

    Graphics.transition

    # Main loop

    loop do

      # Update game screen

      Graphics.update

      # Update input information

      Input.update

      # Frame update

      update

      # Abort loop if screen is changed

      if $scene != self

        break

      end

    end

    # Prepare for transition

    Graphics.freeze

    # Dispose of windows

    @help_window.dispose

    @status_window.dispose

    @skill_window.dispose

    @target_window.dispose

  end

end

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

# ** Scene_Equip

#------------------------------------------------------------------------------

#  This class performs equipment screen processing.

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

class Scene_Equip

  #--------------------------------------------------------------------------

  # * Main Processing

  #--------------------------------------------------------------------------

  def main  

    #

    ## Get actor

    #@actor = $game_party.actors[@actor_index]

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    # * Beginning of Replaced Code

    #------------------------------------------------------------------------

    # If actor index within party size

    if @actor_index < $game_party.actors.size

      # Get actor from party

      @actor = $game_party.actors[@actor_index]

    else

      # Otherwise get actor from reserve party

      idx = @actor_index - $game_party.actors.size

      @actor = $game_party.reserve_actors[idx]

    end

    #------------------------------------------------------------------------

    # * Replaced Code End

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    #

    # Make windows

    @help_window = Window_Help.new

    @left_window = Window_EquipLeft.new(@actor)

    @right_window = Window_EquipRight.new(@actor)

    @item_window1 = Window_EquipItem.new(@actor, 0)

    @item_window2 = Window_EquipItem.new(@actor, 1)

    @item_window3 = Window_EquipItem.new(@actor, 2)

    @item_window4 = Window_EquipItem.new(@actor, 3)

    @item_window5 = Window_EquipItem.new(@actor, 4)

    # Associate help window

    @right_window.help_window = @help_window

    @item_window1.help_window = @help_window

    @item_window2.help_window = @help_window

    @item_window3.help_window = @help_window

    @item_window4.help_window = @help_window

    @item_window5.help_window = @help_window

    # Set cursor position

    @right_window.index = @equip_index

    refresh

    # Execute transition

    Graphics.transition

    # Main loop

    loop do

      # Update game screen

      Graphics.update

      # Update input information

      Input.update

      # Frame update

      update

      # Abort loop if screen is changed

      if $scene != self

        break

      end

    end

    # Prepare for transition

    Graphics.freeze

    # Dispose of windows

    @help_window.dispose

    @left_window.dispose

    @right_window.dispose

    @item_window1.dispose

    @item_window2.dispose

    @item_window3.dispose

    @item_window4.dispose

    @item_window5.dispose

    #

  end

end

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

# ** Scene_Battle

#------------------------------------------------------------------------------

#  This class performs battle screen processing.

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

class Scene_Battle

  #--------------------------------------------------------------------------

  # * Start After Battle Phase

  #--------------------------------------------------------------------------

  def start_phase5

    #

    # Shift to phase 5

    @phase = 5

    # Play battle end ME

    $game_system.me_play($game_system.battle_end_me)

    # Return to BGM before battle started

    $game_system.bgm_play($game_temp.map_bgm)

    # Initialize EXP, amount of gold, and treasure

    exp = 0

    gold = 0

    treasures = []

    # Loop

    for enemy in $game_troop.enemies

      # If enemy is not hidden

      unless enemy.hidden

        # Add EXP and amount of gold obtained

        exp += enemy.exp

        gold += enemy.gold

        # Determine if treasure appears

        if rand(100) < enemy.treasure_prob

          if enemy.item_id > 0

            treasures.push($data_items[enemy.item_id])

          end

          if enemy.weapon_id > 0

            treasures.push($data_weapons[enemy.weapon_id])

          end

          if enemy.armor_id > 0

            treasures.push($data_armors[enemy.armor_id])

          end

        end

      end

    end

    # Treasure is limited to a maximum of 6 items

    treasures = treasures[0..5]

    # Obtaining EXP

    for i in 0...$game_party.actors.size

      actor = $game_party.actors[i]

      if actor.cant_get_exp? == false

        last_level = actor.level

        actor.exp += exp

        if actor.level > last_level

          @status_window.level_up(i)

        end

      end

    end

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    # * Beginning of Inserted Code

    #------------------------------------------------------------------------

    # Obtain Reserve Character Exp Percentage

    perc = RPGAdvReserve::EXP_PERCENT

    # Reserve Characters Obtaining EXP    

    for i in 0...$game_party.reserve_actors.size

      actor = $game_party.reserve_actors[i]

      if actor.cant_get_exp? == false

        actor.exp += exp * perc / 100

      end

    end

    #------------------------------------------------------------------------

    # * Inserted  Code End

    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    # Obtaining gold

    $game_party.gain_gold(gold)

    # Obtaining treasure

    for item in treasures

      case item

      when RPG::Item

        $game_party.gain_item(item.id, 1)

      when RPG::Weapon

        $game_party.gain_weapon(item.id, 1)

      when RPG::Armor

        $game_party.gain_armor(item.id, 1)

      end

    end

    # Make battle result window

    @result_window = Window_BattleResult.new(exp, gold, treasures)

    # Set wait count

    @phase5_wait_count = 100

    #

  end

end

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

# ** Scene_ChangeParty

#------------------------------------------------------------------------------

#  This class performs party management processing.

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

class Scene_ChangeParty

  #--------------------------------------------------------------------------

  # * Object Initialization

  #     max_size : max size of party

  #--------------------------------------------------------------------------

  def initialize(max_size=0)

    #

    # Obtain text warning

    text = RPGAdvReserve::SIZE_Invalid

    # Set message and exit If below 0

    if max_size < 0

      print(text)

      return

    end

    # Set message and exit if above standard limit of 4

    if max_size > 4

      print(text)

      return

    end    

    # Set max size based on index positions (0-3) rather than (1-4)

    @max_size = max_size

    #

  end

  #--------------------------------------------------------------------------

  # * Main Processing

  #--------------------------------------------------------------------------

  def main

    #

    # Define party max for Change Party menu (0-3)

    party_max   = @max_size

    party_max   = 4 if party_max == 0

    party_max   -= 1

    # Make windows

    @party_window   = Window_ChangeMain.new(party_max)

    @reserve_window = Window_ChangeReserve.new

    @info_window    = Window_PartyChangeInfo.new(@max_size)

    # Set window values

    @party_window.index     = 0

    @reserve_window.index   = -1

    @party_window.active    = true

    @reserve_window.active  = false

    # Clear memorized actors

    @actor1 = nil

    @actor2 = nil

    # Execute transition

    Graphics.transition

    # Main loop

    loop do

      # Update game screen

      Graphics.update

      # Update input information

      Input.update

      # Frame update

      update

      # Abort loop if screen is changed

      if $scene != self

        break

      end

    end

    # Prepare for transition

    Graphics.freeze

    # Dispose of windows

    @party_window.dispose

    @reserve_window.dispose

    @info_window.dispose

  end

  #--------------------------------------------------------------------------

  # * Main Processing

  #--------------------------------------------------------------------------

  def update

    # Update windows    

    @party_window.update

    @reserve_window.update

    @info_window.update

    # If party window is active: call update_party

    return update_party     if @party_window.active

    # If reserve window is active: call update_reserve

    return update_reserve   if @reserve_window.active

  end

  #--------------------------------------------------------------------------

  # * Frame Update (when updating the party window)

  #--------------------------------------------------------------------------

  def update_party

    # If B button was pressed

    if Input.trigger?(Input::B)

      # If party is empty and not permitted to empty

      if $game_party.actors.size == 0 && !RPGAdvReserve::PERMIT_EMPTY

        # Play buzzer SE

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      # If party is larger than maximum size

      val = @max_size

      val = 4 if val == 0

      if $game_party.actors.size > val

        # Play buzzer SE

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      # Play cancel SE

      $game_system.se_play($data_system.cancel_se)

      # Switch to map screen

      $scene = Scene_Map.new

      return

    end

    # If C button was pressed

    if Input.trigger?(Input::C)

      # Set party window cursor position

      place = @party_window.index

      # if cursor goes beyond party size and no one in that spot

      if @max_size > 0

        if place >= @max_size

          if $game_party.actors[place].nil?

            # Play buzzer SE

            $game_system.se_play($data_system.buzzer_se)

            return

          end

        end

      end

      # If party member exists at cursor position

      if $game_party.actors[place] != nil

        # And if party is required (cannot remove)

        if $game_party.actors[place].required

          # Play buzzer SE

          $game_system.se_play($data_system.buzzer_se)

          return

        end

      end

      # If there are no reserve party members

      if $game_party.reserve_actors.size == 0

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Transfer the actor to the reserve party

        $game_party.transfer_to_reserve($game_party.actors[place])

        # Refresh both windows

        @party_window.refresh

        @reserve_window.refresh

        return

      end

      # If reserve party members exist

      if $game_party.reserve_actors.size > 0

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Make reserve window active

        @party_window.active    = false

        @reserve_window.index   = 0

        @reserve_window.active  = true

        # Memorize party member

        @actor1 = $game_party.actors[place]

        return

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Frame Update (when updating the reserve window)

  #--------------------------------------------------------------------------

  def update_reserve

    # If B button was pressed

    if Input.trigger?(Input::B)

      # Play cancel SE

      $game_system.se_play($data_system.cancel_se)

      # Make party window active

      update_activate_party_window

      return

    end

    # If C button was pressed

    if Input.trigger?(Input::C)

      # Set reserve window cursor position

      place = @reserve_window.index

      # if cursor goes beyond reserve party size

      if place == $game_party.reserve_actors.size

        # If no memorized party actor

        if @actor1 == nil

          # Play buzzer SE

          $game_system.se_play($data_system.buzzer_se)

          return

        end

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Transfer stored party member to reserves

        $game_party.transfer_to_reserve(@actor1)

        # Make party window active

        update_activate_party_window

        return

      end

      # If there is no stored party actor

      if @actor1 == nil

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Memorize reserve member

        @actor2 = $game_party.reserve_actors[place]

        # Transfer reserve member to party

        $game_party.transfer_to_party(@actor2)

        # Make party window active

        update_activate_party_window

        return

      # If there a stored party actor exists

      else

        # Play decision SE

        $game_system.se_play($data_system.decision_se)

        # Memorize reserve member

        @actor2 = $game_party.reserve_actors[place]

        # Swap both party and reserve party members

        $game_party.swap(@actor1, @actor2)

        # Make party window active

        update_activate_party_window

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Frame Update (when making the party window active)

  #--------------------------------------------------------------------------

  def update_activate_party_window

    #

    # Make party window active

    @reserve_window.index   = -1

    @reserve_window.active  = false

    @party_window.active    = true

    @party_window.refresh

    @reserve_window.refresh

    #

  end

end

Instructions
Place below Scene_Debug and above Main. It rewrites methods in four Scene_ classes, so it should be high in your list of custom scripts. Be aware it may conflict with the menu, skill, equip and battle treasure systems.

Detailed instructions are included in the script itself.

Compatibility
As noted, there are major rewrites. Be warned.

Credits and Thanks
RPGAdvocate for the original version.

Terms and Conditions
There were no terms of use listed at RPG Advocate's site, Phylomortis.com. However, I would think it would be prudent to give him credit for the work.

KustomElemState XP

Tue, 26 May 2026 03:36:40 +0000

KustomElemState XP

by Kyonides

The Script is NOT COMPATIBLE With Other Element or State Related Scripts!

Introduction

It's a very brief one for sure.
Alter a given Actor's element or state rate during gameplay!
The script creates or loads the custom ranks based on the current class.
It will never try to alter the Classes database contents!

Element / State Efficiency Letter 2 Percentage Conversion Table

A - 200% (Weak)
B - 150%
C - 100% (Default)
D - 50%
E - 0% (Immune)
F - -100% (Gets Healed?)

Script Calls

STEP 1
Get an Actor first! - 2 Methods:

Code:
actor = $game_party.actors[Index]

actor = $game_actors[ActorID]

STEP 2
Use any of the following calls.

Check out the current Index of an Element Rate:

Code:
actor.find_element_rate(ElementID)

Check out the current Effect % of an Element:

Code:
actor.element_effect(ElementID)

Change an Actor's Element Rate! Rate Indices: 1 through 6

Code:
actor.custom_element_rank(ElementID, RateIndex)

Change an Actor's State Rate! Rate Indices: 1 through 6

Code:
actor.custom_state_rank(StateID, RateIndex)

Move Current Element State 1 Position to the Left

Code:
actor.prev_element_rate!(ElementID)

Move Current Element State 1 Position to the Right

Code:
actor.next_element_rate!(ElementID)

USAGE EXAMPLE

The Script

Code:
# * KustomElemState XP * #

#   Scripter : Kyonides

#   2025-05-25

# * NOT COMPATIBLE With Other Element or State Related Scripts! * #

# Alter a given Actor's element or state rate during gameplay!

# The script creates / loads the custom ranks based on the current class.

# It will never try to alter the Classes DB contents!

# * Script Calls * #

# STEP #1: Get an Actor first! - 2 Methods:

# actor = $game_party.actors[Index]

# actor = $game_actors[ActorID]

# STEP #2: Use any of the following calls.

# - Check out the current Index of an Element Rate:

# actor.find_element_rate(ElementID)

# - Check out the current Effect % of an Element:

# actor.element_effect(ElementID)

# - Change an Actor's Element Rate!  Rate Indices: 1 through 6

# actor.custom_element_rank(ElementID, RateIndex)

# - Change an Actor's State Rate!    Rate Indices: 1 through 6

# actor.custom_state_rank(StateID, RateIndex)

# - Move Current Element State 1 Position to the Left

# actor.prev_element_rate!(ElementID)

# - Move Current Element State 1 Position to the Right

# actor.next_element_rate!(ElementID)

class Game_Actor

  ER_TABLE = [0,200,150,100,50,0,-100]

  alias :kyon_kust_elem_stt_gm_act_setup :setup

  alias :kyon_kust_elem_stt_gm_act_class_id_set :class_id=

  def setup(actor_id)

    kyon_kust_elem_stt_gm_act_setup(actor_id)

    @element_ranks = {}

    @state_ranks = {}

    custom_element_ranks!

    custom_state_ranks!

  end

  def custom_element_ranks!

    @element_ranks[@class_id] ||= $data_classes[@class_id].element_ranks.dup

  end

  def custom_state_ranks!

    @state_ranks[@class_id] ||= $data_classes[@class_id].state_ranks.dup

  end

  def find_element_rate(elem_id)

    @element_ranks[@class_id][elem_id]

  end

  def element_effect(elem_id)

    n = find_element_rate(elem_id)

    ER_TABLE[n]

  end

  def armor_ids

    [@armor1_id, @armor2_id, @armor3_id, @armor4_id]

  end

  def element_rate(element_id)

    pos = find_element_rate(element_id)

    result = ER_TABLE[pos]

    armor_ids.each do |i|

      armor = $data_armors[i]

      if armor != nil and armor.guard_element_set.include?(element_id)

        result /= 2

      end

    end

    @states.each do |i|

      if $data_states[i].guard_element_set.include?(element_id)

        result /= 2

      end

    end

    return result

  end

  def state_ranks

    @state_ranks[@class_id]

  end

  def custom_element_rank(n, value)

    @element_ranks[@class_id][n] = value

  end

  def custom_state_rank(n, value)

    @state_ranks[@class_id][n] = value

  end

  def class_id=(class_id)

    class_id_set(class_id)

    custom_element_ranks!

    custom_state_ranks!

  end

  def change_element_rate(elem_id, value, start)

    pos = find_element_rate(elem_id)

    pos = (pos + value) % 7

    pos = start if pos == 0

    custom_element_rank(elem_id, pos)

    pos

  end

  def prev_element_rate!(elem_id)

    change_element_rate(elem_id, -1, 6)

  end

  def next_element_rate!(elem_id)

    change_element_rate(elem_id, 1, 1)

  end

end

Terms & Conditions

Free as in beer.
Mention me in your game credits.
That's it!

Aced Shops

Sun, 17 May 2026 18:59:31 +0000

Aced Shops
Version: 1.2
Initial development began 5-16-2026

Introduction

This script lets one set up shops that may limit interactions. In general it permits these functions:

Can make a store that only buys from the player or only does sales.
Can restrict items sold to inddividual stores based on the item IDs
Can set up a store to have custom prices for certain items
Can make a virtual Dynamic Shop with limited goods until restocked
Can have favorable or dissatisfied reactions affect store prices
I was always a fan of Bethesda Softwork's mercantile price alteration systems

BONUS: Demo includes the "Advanced Shop Status Window" script by RPG Advocate

Demo
CLICK HERE-- Box.Com link
Look for the Download link in the top right of the screen

Instructions
On this release, I was barebones on instructions. I will return later with more instructions.

FAQ

This was per a request by Ace_V, said request and development found here:
https://www.save-point.org/thread-13478-lastpost.html

While development began initially with RPG Advocate's Buy Only/Sell-Only script, little of it even remains.

Compatibility

Performs several rewrites throughout the shop system.

Terms and Conditions

Free for use, even in commercial games. Only due credit is required.

KustomPriceShop XP

Sun, 17 May 2026 07:20:19 +0000

KustomPriceShop XP

by Kyonides

Introduction

This script allows you to open a special shop on a given map that offers:

Setting custom (buy or sale) prices for specific items.
Setting certain goods as highly undesirable, making the party lose friendship points at that shop.
Rewarding loyal customers with free gifts if they buy a given amount of items or weapons or armors.
Creating buy-only or sell-only shops.

To keep it separate from normal shops, set the shop's ID via a game variable.

You can change the maximum number of units per item allowed in your game.

Leaving the shop without doing anything will decrease the shop's friendship points by 1 (default value).
Purchases and sales will increase those points in no time!

It also lets you to set a backdrop as well instead of the current map.

SCREENSHOTS

Optional Script Calls For The Active Shop

NOTE: ItemID stands for an actual positive number, starting from 1 onwards.

Add Items with Custom Prices:

Code:
buy_price_items(ItemID1 => Price1, etc.)

sell_price_items(ItemID1 => Price1, etc.)

Add Weapons with Custom Prices:

Code:
buy_price_weapons(WeaponID1 => Price1, etc.)

sell_price_weapons(WeaponID1 => Price1, etc.)

Add Armors with Custom Prices:

Code:
buy_price_armors(ArmorID1 => Price1, etc.)

sell_price_armors(ArmorID1 => Price1, etc.)

Change Custom Price Shop's Friendship Points - Number stands for any number, either positive or negative.

Code:
price_shop_friend_points(Number)

Set Minimum Friendship Level for Certain Items, Weapons or Armors - Types: 0 - Item, 1 - Weapon, 2 - Armor

Code:
price_shop_friendship_min(Mininum, Type, ItemID1, etc.)

Set the Lowest Level The Friendship Points can reach: Number should be equal to 0 or less.

Code:
price_shop_friend_floor(Number)

Change Custom Price Shop's No Transaction Penalty - Number stands for 0 or any positive number. Default Value: 1.

Code:
price_shop_set_no_action_penalty(Number)

Reward Your Loyal Customers with Items:

Code:
buy_gifts_items(ItemID, ItemsMin, GiftItemID, Number)

Reward Your Loyal Customers with Weapons:

Code:
buy_gifts_weapons(ItemID, ItemsMin, GiftItemID, Number)

Reward Your Loyal Customers with Armors:

Code:
buy_gifts_armors(ItemID, ItemsMin, GiftItemID, Number)

Punish the Player for Selling the "Wrong" Items: LostPoints stands for 1 or above.

Code:
sell_price_wrong_items(ItemID1 => LostPoints, etc.)

Punish the Player for Selling the "Wrong" Weapons:

Code:
sell_price_wrong_weapons(WeaponID1 => LostPoints, etc.)

Punish the Player for Selling the "Wrong" Armors:

Code:
sell_price_wrong_armors(ArmorID1 => LostPoints, etc.)

The Script

Code:
# * KustomPriceShop XP * #

#   Scripter : Kyonides

#   v1.0.0 - 2026-05-23

# Create a special shop that offers:

# - Setting custom prices for specific items.

# - Setting certain goods as highly undesirable, making the party lose

#   friendship points at that shop.

# - Rewarding loyal customers with free gifts if they buy a given amount of

#   items or weapons or armors.

# - Creating purchase-only or sell-only shops.

# To keep it separate from normal shops, set the shop's ID via a game variable.

# You can change the maximum number of units per item allowed in your game.

# It also allows you to set a backdrop as well instead of the current map.

# Leaving the shop without doing anything will decrease the shop's friendship

# points by 1 (default value).

# * Optional Script Calls For The Active Shop * #

# - Add Items with Custom Prices:

# buy_price_items(ItemID1 => Price1, etc.)

# sell_price_items(ItemID1 => Price1, etc.)

# - Add Weapons with Custom Prices:

# buy_price_weapons(WeaponID1 => Price1, etc.)

# sell_price_weapons(WeaponID1 => Price1, etc.)

# - Add Armors with Custom Prices:

# buy_price_armors(ArmorID1 => Price1, etc.)

# sell_price_armors(ArmorID1 => Price1, etc.)

# - Change Custom Price Shop's Friendship Points:

#   Number stands for any number, either positive or negative.

# price_shop_friend_points(Number)

# - Set Minimum Friendship Level for Certain Items, Weapons or Armors:

#   Types: 0 - Item, 1 - Weapon, 2 - Armor

# price_shop_friendship_min(Mininum, Type, ItemID1, etc.)

# - Set the Lowest Level The Friendship Points can reach: 0 or less.

# price_shop_friend_floor(Number)

# - Change Custom Price Shop's No Transaction Penalty:

#   Number stands for 0 or any positive number. Default Value: 1.

# price_shop_set_no_action_penalty(Number)

# - Reward Your Loyal Customers with Items:

# buy_gifts_items(ItemID, ItemsMin, GiftItemID, Number)

# - Reward Your Loyal Customers with Weapons:

# buy_gifts_weapons(ItemID, ItemsMin, GiftItemID, Number)

# - Reward Your Loyal Customers with Armors:

# buy_gifts_armors(ItemID, ItemsMin, GiftItemID, Number)

# - Punish the Player for Selling the Wrong Items:

# sell_price_wrong_items(ItemID1 => LostPoints, etc.)

# - Punish the Player for Selling the Wrong Weapons:

# sell_price_wrong_weapons(WeaponID1 => LostPoints, etc.)

# - Punish the Player for Selling the Wrong Armors:

# sell_price_wrong_armors(ArmorID1 => LostPoints, etc.)

module KustomPrice

  ITEM_MAX = 99

  BUY_ONLY_SWITCH  = 8

  SELL_ONLY_SWITCH = 9

  SHOP_ID_VAR = 10

  DEFAULT_BACKDROP = "012-PortTown02"

  FRIENDSHIP_LEVEL = "Friendship Level: %s"

  SPECIAL_REWARDS  = "Special Rewards"

  class Shop

    class Gifts

      def initialize(item_min, item_id, n)

        @item_min = item_min

        @item_id = item_id

        @amount = n

      end

      attr_reader :item_min, :item_id, :amount

    end

    def initialize

      @friendship = 0

      @friendship_floor = 0

      @no_action_penalty = 1

      @friendship_min = {}

      @buy_prices = {}

      @sell_prices = {}

      @buy_item_max = {}

      @sell_item_max = {}

      @buy_gifts = {}

      @sell_wrong_goods = {}

      @friendship_min.default = {}

      @buy_prices.default = {}

      @sell_prices.default = {}

      @buy_gifts.default = {}

      @sell_wrong_goods.default = {}

      @buy_item_max.default = ITEM_MAX

      @sell_item_max.default = ITEM_MAX

    end

    def friendship=(n)

      @friendship = [@friendship + n, @friendship_floor].max

    end

    def no_action_penalty!

      self.friendship -= @no_action_penalty

    end

    def frienship_min(mininum, type, *items)

      fmin = @friendship_min[type]

      items.flatten.each {|n| fmin[n] = mininum }

      mininum

    end

    def set_buy_prices(type, data={})

      @buy_prices[type].merge!(data)

    end

    def set_sell_prices(type, data={})

      @sell_prices[type].merge!(data)

    end

    def set_buy_gifts(type, parent_id, item_min, item_id, n)

      @buy_gifts[type][parent_id] = Gifts.new(item_min, item_id, n)

    end

    def sell_wrong_goods(type, data={})

      @sell_wrong_goods[type].merge!(data)

    end

    attr_reader :friendship, :friendship_floor, :friendship_min

    attr_reader :buy_prices, :sell_prices, :buy_gifts

    attr_reader :buy_item_max, :sell_item_max, :sell_wrong_goods

    attr_accessor :goods, :no_action_penalty

  end

end

class Game_System

  alias :kyon_kp_shop_gm_sys_init :initialize

  def initialize

    kyon_kp_shop_gm_sys_init

    reset_price_shop_id!

    @custom_price_shops = {}

  end

  def reset_price_shop_id!

    @price_shop_id = 0

  end

  def init_price_shop(shop_id)

    @price_shop_id = shop_id

    @custom_price_shops[shop_id] ||= KustomPrice::Shop.new

  end

  def setup_price_shop(shop_id, new_goods)

    shop = @custom_price_shops[shop_id]

    shop.goods = new_goods

  end

  def this_price_shop

    @custom_price_shops[@price_shop_id]

  end

  attr_reader :custom_price_shops

end

class Game_Party

  def bag_items

    @items

  end

  def bag_weapons

    @weapons

  end

  def bag_armors

    @armors

  end

  def compact_bag_items!

    @items.delete_if {|k,v| v == 0 }

    @weapons.delete_if {|k,v| v == 0 }

    @armors.delete_if {|k,v| v == 0 }

  end

end

class Window_ShopCommand

  def reset_disabled_items

    @disabled = []

  end

  def disable_current_item?

    @disabled[@index]

  end

end

module KustomPrice

  module AddMethods

    def item

      @data[@index] || @no_item

    end

    def price

      @prices[@index] || 0

    end

    def type

      @types[@index] || 0

    end

    def get_price(n, item_id, price)

      case @types[n]

      when 0

        @item_prices[item_id] || price

      when 1

        @weapon_prices[item_id] || price

      when 2

        @armor_prices[item_id] || price

      end

    end

  end

class ShopBuyWindow < Window_Selectable

  include AddMethods

  attr_accessor :shop_goods

  def initialize(shop, shop_goods)

    w = 368

    @tw = w - 64

    super(0, 288, w, 192)

    sp = shop.buy_prices

    @item_prices   = sp[0]

    @weapon_prices = sp[1]

    @armor_prices  = sp[2]

    @shop_goods = shop_goods.dup

    @no_item = RPG::Item.new

    @transparent = Color.new(0, 0, 0, 0)

    @symbol_color = Color.new(255, 255, 80)

    @symbol = $data_system.words.gold

    refresh

    self.index = 0

  end

  def item_name

    self.item.name

  end

  def set_goods(goods_item)

    type, goods_id = goods_item

    case type

    when 0

      [type, $data_items[goods_id]]

    when 1

      [type, $data_weapons[goods_id]]

    when 2

      [type, $data_armors[goods_id]]

    end

  end

  def refresh

    if self.contents != nil

      self.contents.dispose

      self.contents = nil

    end

    @types = []

    @data = []

    @prices = []

    for goods_item in @shop_goods

      type, item = set_goods(goods_item)

      next unless item

      n = @types.size

      @types << type

      @data << item

      @prices << get_price(n, item.id, item.price)

    end

    draw_items

  end

  def draw_items

    @item_max = @data.size

    self.contents = Bitmap.new(width - 32, row_max * 32) if @item_max > 0

    @item_max.times {|i| draw_item(i) }

  end

  def clear_line(rx, ry)

    rect = Rect.new(rx, ry, self.width - 32, 32)

    self.contents.fill_rect(rect, @transparent)

  end

  def draw_item(n)

    item = @data[n]

    font = self.contents.font

    price = @prices[n]

    if $game_party.gold >= price

      font.color = normal_color

      alpha = 255

    else

      font.color = disabled_color

      alpha = 128

    end

    ry = n * 32

    clear_line(4, ry)

    bitmap = RPG::Cache.icon(item.icon_name)

    self.contents.blt(28, ry + 4, bitmap, Rect.new(0, 0, 24, 24), alpha)

    self.contents.draw_text(56, ry, @tw - 100, 32, item.name)

    self.contents.draw_text(@tw - 92, ry, 100, 32, price.to_s, 2)

    @symbol_color.alpha = alpha

    font.color = @symbol_color

    self.contents.draw_text(@tw, ry, 24, 32, @symbol, 2)

  end

  def update_help

    @help_window.set_text(self.item.description)

  end

  def delete_item

    @shop_goods.delete(@index)

    item = @data.delete(@index)

    self.contents.dispose if self.contents != nil

    self.contents = nil

    draw_items

  end

  def disable_item(n)

    draw_item(n, disabled_color)

    @disabled[n] = true

  end

end

class ShopSellWindow < Window_Selectable

  include AddMethods

  def initialize(shop)

    super(0, 128, 640, 352)

    @column_max = 2

    @no_item = RPG::Item.new

    sp = shop.sell_prices

    @item_prices   = sp[0]

    @weapon_prices = sp[1]

    @armor_prices  = sp[2]

    refresh

    self.index = 0

  end

  def refresh

    if self.contents != nil

      self.contents.dispose

      self.contents = nil

    end

    @types = []

    @data = []

    @prices = []

    n = 0

    $game_party.bag_items.sort.each do |k,v|

      next if $game_party.item_number(k) == 0

      @types << 0

      @data << obj = $data_items[k]

      @prices << get_price(n, k, obj.price / 2)

      n += 1

    end

    $game_party.bag_weapons.sort.each do |k,v|

      next if $game_party.weapon_number(i) == 0

      @types << 1

      @data << obj = $data_weapons[k]

      @prices << get_price(n, k, obj.price / 2)

      n += 1

    end

    $game_party.bag_armors.sort.each do |k,v|

      next if $game_party.armor_number(i) == 0

      @types << 2

      @data << obj = $data_armors[k]

      @prices << get_price(n, k, obj.price / 2)

      n += 1

    end

    @item_max = @data.size

    return if @item_max == 0

    self.contents = Bitmap.new(width - 32, row_max * 32)

    @item_max.times {|n| draw_item(n) }

  end

  def draw_item(n)

    item = @data[n]

    case item

    when RPG::Item

      number = $game_party.item_number(item.id)

    when RPG::Weapon

      number = $game_party.weapon_number(item.id)

    when RPG::Armor

      number = $game_party.armor_number(item.id)

    end

    price = @prices[n]

    if price > 0

      self.contents.font.color = normal_color

    else

      self.contents.font.color = disabled_color

    end

    x = 4 + n % 2 * (288 + 32)

    y = n / 2 * 32

    rect = Rect.new(x, y, self.width / @column_max - 32, 32)

    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

    bitmap = RPG::Cache.icon(item.icon_name)

    opacity = self.contents.font.color == normal_color ? 255 : 128

    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)

    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)

    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)

    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)

  end

  def update_help

    @help_window.set_text(self.item.description)

  end

end

class ShopGiftWindow < Window_Selectable

  def initialize

    super(160, 144, 320, 128)

    @w = width - 32

    @h = height - 32

    @types = []

    @gifts = []

    @amounts = []

    @pages = 0

    @index = 0

  end

  def set_gifts(list)

    list.each do |type, gift, n|

      @types << type

      @gifts << gift

      @amounts << n

    end

    @pages = list.size

    refresh

  end

  def change_page(n)

    return if @pages == 1

    @index = (@index + n) % @pages

    refresh

  end

  def refresh

    page = @index + 1

    label = "Page " + page.to_s + "/" + @pages.to_s

    n = @amounts[@index]

    b = Bitmap.new(@w, @h)

    font = b.font

    font.color = system_color

    b.draw_text(0, 0, @w, 32, SPECIAL_REWARDS, 1)

    good = get_good

    font.color = normal_color

    b.draw_text(0, 32, @w, 32, good.name)

    b.draw_text(0, 32, @w, 32, n.to_s, 2)

    b.draw_text(0, 64, @w, 32, label, 2)

    self.contents = b

  end

  def get_good

    item_id = @gifts[@index]

    case @types[@index]

    when 0

      return $data_items[item_id]

    when 1

      return $data_weapons[item_id]

    when 2

      return $data_armors[item_id]

    end

  end

end

end

class Interpreter

  alias :kyon_kp_shop_int_chng_vars :command_122

  def command_122

    kyon_kp_shop_int_chng_vars

    var_id = @parameters[0]

    return unless KustomPrice::SHOP_ID_VAR == var_id

    var_id = @parameters[4]

    @price_shop = $game_system.init_price_shop(var_id)

  end

  def price_shop_friend_points(n)

    @price_shop.friendship += n

  end

  def price_shop_friend_floor(n)

    @price_shop.friendship_floor = n

  end

  def price_shop_friendship_min(min, type, *items)

    @price_shop.frienship_min(min, type, *items)

  end

  def price_shop_set_no_action_penalty(n)

    @price_shop.no_action_penalty = n

  end

  def buy_price_items(data={})

    @price_shop.set_buy_prices(0, data)

  end

  def buy_price_weapons(data={})

    @price_shop.set_buy_prices(1, data)

  end

  def buy_price_armors(data={})

    @price_shop.set_buy_prices(2, data)

  end

  def sell_price_items(data={})

    @price_shop.set_sell_prices(0, data)

  end

  def sell_price_weapons(data={})

    @price_shop.set_sell_prices(1, data)

  end

  def sell_price_armors(data={})

    @price_shop.set_sell_prices(2, data)

  end

  def buy_gifts_items(item_id, item_min, gift_item_id, n)

    @price_shop.set_buy_gifts(0, item_id, item_min, gift_item_id, n)

  end

  def buy_gifts_weapons(item_id, item_min, gift_item_id, n)

    @price_shop.set_buy_gifts(1, item_id, item_min, gift_item_id, n)

  end

  def buy_gifts_armors(item_id, item_min, gift_item_id, n)

    @price_shop.set_buy_gifts(2, item_id, item_min, gift_item_id, n)

  end

  def sell_price_wrong_items(data={})

    @price_shop.sell_wrong_goods(0, data)

  end

  def sell_price_wrong_weapons(data={})

    @price_shop.sell_wrong_goods(1, data)

  end

  def sell_price_wrong_armors(data={})

    @price_shop.sell_wrong_goods(2, data)

  end

end

class Scene_Map

  def call_shop

    $game_temp.shop_calling = false

    $game_player.straighten

    shop_var = KustomPrice::SHOP_ID_VAR

    if $game_variables[shop_var] != 0

      $scene = PriceShopScene.new

    else

      $scene = Scene_Shop.new

    end

  end

end

class PriceShopScene < Scene_Shop

  include KustomPrice

  def find_shop_id

    $game_variables[SHOP_ID_VAR]

  end

  def main

    prepare_goods

    make_backdrop

    make_windows

    Graphics.transition

    loop do

      Graphics.update

      Input.update

      update

      if $scene != self

        break

      end

    end

    Graphics.freeze

    dispose_windows

    reset_price_shop

  end

  def prepare_goods

    $game_party.compact_bag_items!

    @transactions = 0

    @shop_id = find_shop_id

    @shop = $game_system.this_price_shop

    @fp = @shop.friendship

    @fp_min = @shop.friendship_min

    @goods = @shop.goods || $game_temp.shop_goods

    setup_friendly_goods

  end

  def setup_friendly_goods

    @gifts = []

    @shop_goods = []

    @goods.each do |type, obj_id|

      group = @fp_min[type]

      level = group[obj_id] || 0

      @shop_goods << [type, obj_id] if level == 0 or level <= @fp

    end

    @exclude_goods = @shop_goods.size != @goods.size

  end

  def make_backdrop

    @backdrop = Sprite.new

    @backdrop.bitmap = RPG::Cache.battleback(DEFAULT_BACKDROP)

  end

  def make_windows

    @help_window = Window_Help.new

    show_friendship_level

    @command_window = Window_ShopCommand.new

    @command_window.reset_disabled_items

    @command_window.disable_item(0) if $game_switches[SELL_ONLY_SWITCH]

    @command_window.disable_item(1) if $game_switches[BUY_ONLY_SWITCH]

    @gold_window = Window_Gold.new

    @gold_window.x = 480

    @gold_window.y = 64

    @dummy_window = Window_Base.new(0, 288, 640, 192)

    @buy_window = ShopBuyWindow.new(@shop, @shop_goods)

    @buy_window.active = false

    @buy_window.visible = false

    @buy_window.help_window = @help_window

    @sell_window = ShopSellWindow.new(@shop)

    @sell_window.active = false

    @sell_window.visible = false

    @sell_window.help_window = @help_window

    @number_window = Window_ShopNumber.new

    @number_window.active = false

    @number_window.visible = false

    @status_window = Window_ShopStatus.new

    @status_window.visible = false

    @gift_window = ShopGiftWindow.new

    @gift_window.visible = false

  end

  def show_friendship_level

    points = @shop.friendship.to_s

    points = sprintf(FRIENDSHIP_LEVEL, points)

    @help_window.set_text(points)

  end

  def update

    if @show_gifts

      update_show_gifts

      return

    end

    super

  end

  def update_show_gifts

    if Input.trigger?(Input::B) or Input.trigger?(Input::C)

      $game_system.se_play($data_system.cancel_se)

      $scene = Scene_Map.new

      return @show_gifts = nil

    elsif Input.trigger?(Input::LEFT)

      $game_system.se_play($data_system.cursor_se)

      @gift_window.change_page(-1)

      return

    elsif Input.trigger?(Input::RIGHT)

      $game_system.se_play($data_system.cursor_se)

      @gift_window.change_page(1)

    end

  end

  def update_command

    if Input.trigger?(Input::B)

      if @get_gifts

        $game_system.se_play($data_system.shop_se)

        @command_window.index = -1

        @gift_window.set_gifts(@gifts)

        @gift_window.visible = true

        Graphics.screenshot

        @get_gifts = nil

        return @show_gifts = true

      else

        $game_system.se_play($data_system.cancel_se)

        $scene = Scene_Map.new

      end

      return

    elsif Input.trigger?(Input::C)

      if @command_window.disable_current_item?

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      case @command_window.index

      when 0

        open_purchase

      when 1

        open_sale

      when 2

        $game_system.se_play($data_system.decision_se)

        $scene = Scene_Map.new

      end

    end

  end

  def open_purchase

    $game_system.se_play($data_system.decision_se)

    @command_window.active = false

    @dummy_window.visible = false

    @buy_window.active = true

    @buy_window.visible = true

    @buy_window.refresh

    @status_window.visible = true

  end

  def open_sale

    $game_system.se_play($data_system.decision_se)

    @command_window.active = false

    @dummy_window.visible = false

    @sell_window.active = true

    @sell_window.visible = true

    @sell_window.refresh

  end

  def update_buy

    @status_window.item = @buy_window.item

    if Input.trigger?(Input::B)

      $game_system.se_play($data_system.cancel_se)

      @command_window.active = true

      @dummy_window.visible = true

      @buy_window.active = false

      @buy_window.visible = false

      @status_window.visible = false

      @status_window.item = nil

      show_friendship_level

      return

    elsif Input.trigger?(Input::C)

      @item = @buy_window.item

      price = @buy_window.price

      if @item == nil or $game_party.gold < price

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      case @item

      when RPG::Item

        number = $game_party.item_number(@item.id)

      when RPG::Weapon

        number = $game_party.weapon_number(@item.id)

      when RPG::Armor

        number = $game_party.armor_number(@item.id)

      end

      if ITEM_MAX == number

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      $game_system.se_play($data_system.decision_se)

      max = price == 0 ? ITEM_MAX : $game_party.gold / price

      max = [max, ITEM_MAX - number].min

      @buy_window.active = false

      @buy_window.visible = false

      @number_window.set(@item, max, price)

      @number_window.active = true

      @number_window.visible = true

    end

  end

  def update_sell

    if Input.trigger?(Input::B)

      $game_system.se_play($data_system.cancel_se)

      @command_window.active = true

      @dummy_window.visible = true

      @sell_window.active = false

      @sell_window.visible = false

      @status_window.item = nil

      show_friendship_level

      return

    elsif Input.trigger?(Input::C)

      @item = @sell_window.item

      @status_window.item = @item

      price = @sell_window.price

      if @item == nil or price == 0

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      $game_system.se_play($data_system.decision_se)

      case @item

      when RPG::Item

        number = $game_party.item_number(@item.id)

      when RPG::Weapon

        number = $game_party.weapon_number(@item.id)

      when RPG::Armor

        number = $game_party.armor_number(@item.id)

      end

      total = number

      @sell_window.active = false

      @sell_window.visible = false

      @number_window.set(@item, total, price)

      @number_window.active = true

      @number_window.visible = true

      @status_window.visible = true

    end

  end

  def update_number

    if Input.trigger?(Input::B)

      $game_system.se_play($data_system.cancel_se)

      @number_window.active = false

      @number_window.visible = false

      case @command_window.index

      when 0  # buy

        @buy_window.active = true

        @buy_window.visible = true

      when 1  # sell

        @sell_window.active = true

        @sell_window.visible = true

        @status_window.visible = false

      end

      return

    elsif Input.trigger?(Input::C)

      $game_system.se_play($data_system.shop_se)

      @number_window.active = false

      @number_window.visible = false

      item_id = @item.id

      n = @number_window.number

      @transactions += n

      case @command_window.index

      when 0  # buy

        update_number_buy(item_id, n)

        return

      when 1  # sell

        type = @sell_window.type

        lost_points = @shop.sell_wrong_goods[type][item_id] || 0

        if lost_points > 0

          @shop.friendship -= lost_points * n

        else

          @shop.friendship += n

        end

        price = @sell_window.price

        $game_party.gain_gold(n * price)

        case @item

        when RPG::Item

          $game_party.lose_item(item_id, n)

        when RPG::Weapon

          $game_party.lose_weapon(item_id, n)

        when RPG::Armor

          $game_party.lose_armor(item_id, n)

        end

        @gold_window.refresh

        @sell_window.refresh

        @status_window.refresh

        @sell_window.active = true

        @sell_window.visible = true

        @status_window.visible = false

      end

    end

  end

  def update_number_buy(item_id, n)

    @shop.friendship += n

    price = @buy_window.price

    $game_party.lose_gold(n * price)

    case @item

    when RPG::Item

      type = 0

      $game_party.gain_item(item_id, n)

    when RPG::Weapon

      type = 1

      $game_party.gain_weapon(item_id, n)

    when RPG::Armor

      type = 2

      $game_party.gain_armor(item_id, n)

    end

    @gold_window.refresh

    if @shop.friendship != @fp

      @fp = @shop.friendship

      setup_friendly_goods

      @buy_window.shop_goods = @shop_goods

    end

    @buy_window.refresh

    @status_window.refresh

    @buy_window.active = true

    @buy_window.visible = true

    gifts_list = @shop.buy_gifts[type]

    gift = gifts_list[item_id]

    if gift and gift.item_min <= n

      item_id = gift.item_id

      total = n / gift.item_min * gift.amount

      case type

      when 0

        $game_party.gain_item(item_id, total)

      when 1

        $game_party.gain_weapon(item_id, total)

      when 2

        $game_party.gain_armor(item_id, total)

      end

      @gifts << [type, item_id, total]

      @get_gifts = true

    end

  end

  def dispose_windows

    @backdrop.bitmap.dispose

    @backdrop.dispose

    @help_window.dispose

    @command_window.dispose

    @gold_window.dispose

    @dummy_window.dispose

    @buy_window.dispose

    @sell_window.dispose

    @number_window.dispose

    @status_window.dispose

    @gift_window.dispose

  end

  def reset_price_shop

    $game_variables[SHOP_ID_VAR] = 0

    $game_switches[BUY_ONLY_SWITCH] = false

    $game_switches[SELL_ONLY_SWITCH] = false

    $game_party.compact_bag_items!

    @shop.no_action_penalty! if @transactions == 0

    list = @buy_window.shop_goods

    if !@exclude_goods and list.size != @shop_goods.size

      $game_system.setup_price_shop(@shop_id, list)

    end

    $game_system.reset_price_shop_id!

  end

end

Terms & Conditions

Free as in beer.
Mention me in your game credits.
You may also add the forum's name and URL there.
That's it!

Face Sync System Core

Fri, 10 Apr 2026 23:20:44 +0000

Face Sync System Core
Version: 1.0

Introduction

The Face Sync System is perhaps the first of its kind within the RPG Maker community.

Based on a concept by Bethesda Softworks and its lip-file system, Face Sync is a software package that takes the contents of a pre-generated timing data file and then, with that timing, it then displays individual animation cels in concert atop of s designated sprite, whether it is a character sprite on the field map, a character portrait shown within a custom message window, or the like.

The system core covers most of the necessary mechanics, creating the sprites that are rendered, the retrieval of graphics and the timing data, the animation functions, and their removal.

Features

Custom data files that will cache like any other in the data folder
Includes two example scripts showing how to make the requisite data files
Includes a Message Adaptation script to allow face sync in message portraits
Includes a Character Set script to allow face sync on field map sprites

Limitations

Apparently, only one NPC animation per patch script at any one time. You can show lips syncs occur on a character in the field map and in a message profile pic at the same time, but not two character set sprites on the map at the same time.
Map Movement may affect the accuracy of the Face Sync animations

Screenshots

You'd literally be watching someone open and close their mouth.

Demo

Box Com Download

Instructions

Plenty, but in the script

Compatibility

The main core system does not interfere with any content. It requires patch scripts to connect it to suitable message systems (included in the demo).

Credits and Thanks

Thanks to Remi-Chan for the use of Esperia Frostwhisper from her gaming universe for this demo.

Terms and Conditions

Free to use, even in commercial projects. However, I will need some form of due credit.

Esperia Frostwhisper - the sole property of Remi-Chan. All Rights Reserved.

Cammy's Anti-Lag

Sun, 22 Feb 2026 06:12:50 +0000

Cammy's Anti-Lag
Version: 1.1

Introduction

This is a simple-to-use but comprehensive system designed to greatly reduce the amount of lag within the field map when an abundance of events exist. It also has the chance to reduce lag when a game developer has an extensive number of common events in play.

Features

Its an ANTI-LAG. Main focus is to only let events in view function
Has a simple ON/OFF function by defining an RPGMaker XP Switch
Does not rewrite or replace key event or sprite arrays
Allows events so-defined to always run despite being in view or not
Allows events so-defined to never run, basically turning them into tiles
- Events can be defined within their name or by a script call
- Event names are checked the moment you enter the field map
- Script call changes only affect the map on each entry, not saved
Recognizes AutoRun and parallel process events to always run
Recognizes events given a scripted "Set Move Route" to run until done
Limits common events being updated, removing 'trigger only' from the list
- Common events are auto-sorted the first time you enter the field map

Demo

Demo at Box.Com

Instructions

Plenty... in the script.

Compatibility

Designed solely for RPGMaker XP.

Requires rewrites to the Game_Map and Spriteset_Map classes. A second script, Cammy's Anti-Lag Patch, is a simple copy of both classes with the changes clearly marked. Those using the RMXP SDK will not require the patch.

Credits and Thanks

Thanks to Zeriab for the concept of limiting common events.

Author's Notes

Making a map with 999 events is time consuming. Making four virtually identical maps with a lot of individual names with custom anti-lag tags is probably borderline insane.

Terms and Conditions

Free for use, even in commercial games. Only due credit for both myself and Zeriab for the common event feature are required.

ChooseFoes XP

Wed, 18 Feb 2026 02:02:55 +0000

ChooseFoes XP

by Kyonides

Introduction

This scriptlet allows you to open a simple menu where you can choose your enemy's troops based on the current map's random enemy encounter list.
It will use the map's battleback picture as its backdrop. Don't worry about this, it will cover the whole RMXP game screen by default.
You are encouraged to set a custom BGM, otherwise the scene will remain silent until you have finished picking a foe.

AVAILABLE MODES

:accessory
:levels

Accessory Mode

By the way, setting a specific "Choose Foe" accessory is mandatory here!

Actors' Level Average Mode

You must set a default level plus any specific map's average level.

There's now an option to skip the random battle just because.

Optional Script Calls

Change Mode:

Code:
$game_party.choose_foes_mode = :your_mode

Replace the Current Map's Encounter List:

Code:
$game_party.new_map_troops(TroopID1, etc.)

The Script

Version 1.1.0

Code:
# * ChooseFoes XP * #

#   Not Exactly a Plug-n-Play Script

#   Scripter : Kyonides

#   1.1.0 - 2026-06-08

# Aliased Methods: Game_Party#initialize, Scene_Map#call_battle

# This scriptlet allows you to open a simple menu where you can choose your

# enemy's troops based on the current map's random enemy encounter list.

# They will be displayed on screen!

# The new MAP_ID_EXTRA_TROOP hash allows you to set a key-value pair of

# MapID => TroopID to add any given troop found in the Troops DB to that map.

# You can replace the TroopID with a :highest or :lowest or :random symbol.

# Notice: This is entirely optional. Use it only for maps that truly need it.

# Thanks to DerVVulfman's evil suggestion, your players might now face a whole

# new set of foes by using a very specific script call. Feel free to change

# the encounter list as many times as needed. Mwahahaha!!

# - AVAILABLE MODES: :accessory and :levels

# * Accessory Mode * #

# Setting a specific "Choose Foe" accessory is mandatory here!

# * Average Level Mode * #

# You must set a default level plus any specific map's average level.

# * Optional Script Calls * #

# * Change Current Mode:

# $game_party.choose_foes_mode = :your_mode

# * Replace Curent Map's Troop ID's:

# $game_party.new_map_troops(TroopID1, etc.)

module ChooseFoes

  MODE = :levels

  ACCESSORY_ID = 33

  MAP_ACTOR_LVL = {}

  MAP_ACTOR_LVL.default = 5

  MAP_ACTOR_LVL[1] = 4

  # MapID => [TroopID1, etc.] or [:highest] or [:lowest] or [:random]

  MAP_ID_EXTRA_TROOPS = {}

  MAP_ID_EXTRA_TROOPS.default = []

  MAP_ID_EXTRA_TROOPS[1] = [10, 11]

  TITLE = "Pick Your Foe"

  NO_TROOP = "No Troop"

  EXTRA_TROOP = "Special Troop"

  # ["Name", Volume or nil, Pitch or nil]

  BGM = ["052-Negative01", nil, nil]

  class TroopWindow < Window_Selectable

    def initialize(width, commands)

      line_max = [commands.size, 4].min + 1

      @commands = commands

      super(0, 0, width, line_max * 32)

      @item_max = commands.size

      @cw = width - 32

      @rect = Rect.new(4, 0, @cw - 8, 32)

      self.contents = Bitmap.new(@cw, @item_max * 32)

      refresh

      self.index = 0

      @last_index = 0

    end

    def refresh

      self.contents.clear

      @item_max.times {|n| draw_item(n, normal_color) }

    end

    def draw_item(n, color)

      self.contents.font.color = color

      @rect.y = 32 * n

      self.contents.draw_text(@rect, @commands[n])

    end

    def update

      super

      @change_troop = false

      if @index != @last_index

        @last_index = @index

        @change_troop = true

      end

    end

    attr_reader :change_troop

  end

  class Scene

    def initialize(cb, replace_troops)

      @callback = cb

      @trooper_max = 8

      @troop_max = $data_troops.size - 1

      @list = []

      map_id = $game_map.map_id

      if replace_troops

        @list += $game_party.map_troop_ids[map_id]

        @commands = @list.map {|n| $data_troops[n].name }

        n = rand(@list.size)

        @troop_id = @list[n]

      else

        @list += $game_map.encounter_list

        @commands = @list.map {|n| $data_troops[n].name }

        troop_ids = MAP_ID_EXTRA_TROOPS[map_id]

        if MAP_ID_EXTRA_TROOPS.has_key?(map_id)

          troop_ids.each {|n| set_extra_troops(n) }

        end

        @troop_id = $game_temp.battle_troop_id

      end

      @list.unshift(nil)

      @commands.unshift(NO_TROOP)

      @troop = Game_Troop.new

      @troop.setup(@troop_id)

      $game_system.se_play($data_system.battle_start_se)

      $game_system.bgm_stop

      bgm = BGM.compact

      bgm = RPG::AudioFile.new(*bgm)

      Audio.play_anon_bgm(bgm)

    end

    def set_extra_troops(troop_id)

      @commands << EXTRA_TROOP

      case troop_id

      when :lowest

        @list << $game_party.lowest_troop_id

      when :highest

        @list << $game_party.highest_troop_id

      when :random

        @list << $game_party.random_troop_id

      when 1..troop_id

        n = [@troop_max, troop_id].min

        @list << n

      end

    end

    def main

      @stage = true

      fn = $game_map.battleback_name

      bb = RPG::Cache.battleback(fn)

      battle_bit = Bitmap.new(640, 480)

      battle_bit.stretch_blt(battle_bit.rect, bb, bb.rect)

      enemies = @troop.enemies

      @backdrop = Sprite.new

      @backdrop.bitmap = battle_bit

      @vp = Viewport.new(0, 0, 640, 320)

      @vp.z = 200

      @battlers = []

      @trooper_max.times do |n|

        battler = Sprite_Battler.new(@vp, enemies[n])

        battler.change(enemies[n])

        @battlers << battler

      end

      @help_window = Window_Help.new

      @help_window.set_text(TITLE, 1)

      @command_window = TroopWindow.new(240, @commands)

      @command_window.x = 200

      @command_window.y = 320

      @command_window.index = @list.index(@troop_id)

      Input.update

      Graphics.transition(Graphics.frame_rate)

      while @stage

        Graphics.update

        Input.update

        update

      end

      Graphics.freeze

      dispose

    end

    def update

      @command_window.update

      if @command_window.change_troop

        i = @command_window.index

        troop_id = @list[i]

        if troop_id

          @troop.setup(troop_id)

        else

          @troop.empty!

        end

        enemies = @troop.enemies

        @trooper_max.times do |n|

          sbattler = @battlers[n]

          sbattler.change(enemies[n])

        end

      end

      if Input.trigger?(Input::B) or Input.trigger?(Input::C)

        $game_system.se_play($data_system.decision_se)

        @stage = nil

        n = @command_window.index

        troop_id = @list[n]

        if troop_id

          $game_temp.battle_troop_id = troop_id

          @callback.call

          return

        else

          $game_temp.battle_calling = false

          $game_temp.menu_calling = false

          $game_temp.menu_beep = false

          $game_temp.battle_troop_id = 0

          $game_player.make_encounter_count

          $game_player.straighten

          $game_map.autoplay

          $scene = Scene_Map.new

        end

      end

    end

    def dispose

      @battlers.each do |s|

        s.bitmap.dispose if s.bitmap

        s.dispose

      end

      @command_window.dispose

      @help_window.dispose

      @vp.dispose

      @backdrop.bitmap.dispose

      @backdrop.dispose

    end

  end

end

module Audio

  def self.play_anon_bgm(bgm)

    if !bgm or bgm.name.empty?

      bgm_stop

    else

      bgm_play("Audio/BGM/" + bgm.name, bgm.volume, bgm.pitch)

    end

    Graphics.frame_reset

  end

end

class Game_Actor

  def can_pick_foes?

    ChooseFoes::ACCESSORY_ID == @armor4_id and @armor4_id > 0

  end

end

class Game_Party

  alias :kyon_chs_foes_gm_pty_init :initialize

  def initialize

    kyon_chs_foes_gm_pty_init

    @choose_foes_mode = ChooseFoes::MODE

    @defeated_troop_ids = []

    @map_troop_ids = {}

  end

  def choose_foes_with_accessory?

    @actors.find {|a| a.can_pick_foes? } != nil

  end

  def choose_foes_level_avg?

    avg_level = @actors.inject(0) {|t, a| t + a.level }

    avg_level /= @actors.size

    map_level = ChooseFoes::MAP_ACTOR_LVL[$game_map.map_id]

    avg_level >= map_level

  end

  def choose_foes?

    case @choose_foes_mode

    when :accessory

      return choose_foes_with_accessory?

    when :levels

      return choose_foes_level_avg?

    end

  end

  def lowest_troop_id

    @defeated_troop_ids.min || 1

  end

  def highest_troop_id

    @defeated_troop_ids.max || 1

  end

  def random_troop_id

    n = rand(@defeated_troop_ids.size)

    @defeated_troop_ids[n] || 1

  end

  def new_map_troops?(map_id)

    @map_troop_ids.has_key?(map_id)

  end

  def new_map_troops(*troop_ids)

    n = $game_map.map_id

    @map_troop_ids[n] = troop_ids.flatten

  end

  attr_accessor :choose_foes_mode, :map_troop_ids

  attr_reader :defeated_troop_ids

end

class Game_Troop

  def empty!

    @enemies = []

  end

end

class Sprite_Battler

  def change(battler)

    @battler = battler

    unless @battler

      self.bitmap = nil

      loop_animation(nil)

      return

    end

    @battler_name = @battler.battler_name

    @battler_hue = @battler.battler_hue

    self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)

    @width = self.bitmap.width

    @height = self.bitmap.height

    self.ox = @width / 2

    self.oy = @height

    self.x = @battler.screen_x

    self.y = @battler.screen_y

    self.z = @battler.screen_z

  end

end

class Scene_Map

  alias :kyon_chs_foes_scn_mp_cll_btl :call_battle

  def call_battle

    list = $game_map.encounter_list

    if list.size < 2

      kyon_chs_foes_scn_mp_cll_btl

      return

    else

      cb = method(:kyon_chs_foes_scn_mp_cll_btl)

      map_id = $game_map.map_id

      if $game_party.new_map_troops?(map_id)

        $scene = ChooseFoes::Scene.new(cb, true)

      elsif $game_party.choose_foes?

        $scene = ChooseFoes::Scene.new(cb, false)

      end

    end

  end

end

Terms & Conditions

Free as in beer.
Include my nickname in your game credits.
You may mention this forum there as well.
That's it!

No Dodge / Not Today

Sun, 15 Feb 2026 16:29:59 +0000

No Dodge / Not Today
Version: 1.0

Introduction

Did you enjoy a feature in the older RPGMaker engines that allowed weapons to avoid or bypass evade or dodge rates? Do you want an attack that looks at an enemy who is fleet-of-foot and say "Nope! Not today, pal!" and just fry him with a fire blast regardless of how high his evasion rate was set?

This script lets you determine which attack objects can slip in and bypass the evasion rate of a battler, be it hero or enemy. Indeed, you may craft weapons that can get past the EVA score of a custom Hydra, even if set to a score of 99. Or you can create a lethal Kobold boss who can get through and ignore the excellent EVA rating of your hero's armor.

Features

Define weapons that ignore target EVA scores (akin to RM2K+ dodge rates)
Define skills, states and items that ignore target EVA scores
Make enemies capable of ignoring hero armor EVA scores

Screenshots

Nothing to see here. Its a base mechanics system with no visible flourishes

Demo

Nah.

Script

No Dodging Allowed!!!

Code:
#==============================================================================

# ** No Dodge / Not Today

#------------------------------------------------------------------------------

#    by DerVVulfman

#    version 1.0

#    02-15-2026 (MM-DD-YYYY)

#    RGSS / RMXP

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

#

#  INTRODUCTION:

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

#

#  Did you enjoy a feature in the older RPGMaker engines that allowed weapons

#  to avoid or bypass evade or dodge rates?  Do you want an attack that looks

#  at an enemy who is fleet-of-foot and say "Nope!  Not today, pal!" and just

#  fry him with a fire blast regardless of how high his evasion rate was set?

#

#  This script lets you determine which attack objects can slip in and bypass

#  the evasion rate of a battler, be it hero or enemy.  Indeed, you may craft

#  weapons that can get past the EVA score of a custom Hydra,  even if set to

#  a score of 99.  Or you can create a lethal Kobold boss who can get through

#  and ignore the excellent EVA rating of your hero's armor.

#

#

#------------------------------------------------------------------------------

#

#  INSTRUCTIONS:

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

#

#  You just fill the appropriate array in the config section  with the IDs of

#  your weapons, skills, or like effects  that ignore the target's EVA value.

#  That's REALLY all there is to it.

#

#

#------------------------------------------------------------------------------

#

#  WEIRD NOTE:

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

#

#  You just fill the appropriate array in the config section  with the IDs of

#  By default,  enemies do not use weapons or any form of gear. So enemies do

#  not have any form  of 'weapon_id' value applied.  But,  if a scripter does

#  make weapon use possible for enemies,  I made a value  in the config setup

#  to permit such a value to be tested.  I don't expect this to be used much.

#

#

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

#

#  COMPATABILITY:

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

#

#  Designed solely for RPGMaker XP.

#

#  All contents have been aliased, or had code attached to existing methods

#  without rewrites.

#

#

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

#

#  TERMS AND CONDITIONS:

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

#

#  Free for use, even in commercial projects.  Only due credit for myself and

#  Ace_V who suggested a like feature is required.

#

#

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

module NoEvade

  # IDENTIFIER ARRAYS

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

  # Here, you list the IDs of the weapons, skills, items and even states that

  # an attacker may have that makes an enemy unable to evade.

  # ---------------------------------------------------------------------------

  #

    ENEMY_IDS       = [2]       # State IDs here  (default/example: Basilisk)

    STATE_IDS       = [13]      # State IDs here  (default/example: Sharp)

    WEAPON_IDS      = [1]       # Weapon IDs here (default/example: Bronze Sw)

    SKILL_IDS       = [7]       # Skill IDs here  (default/example: Fire)

    ITEM_IDS        = []        # Item IDs here:  (default/example: -none-)

  # WEAPON USING ENEMIES

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

  # Rarely if ever touched, this setting informs the system if a Game_Enemy

  # is able to use an equipped weapon, suggesting a custom script in use.

  # ---------------------------------------------------------------------------

  #    

    ENEMY_WEAPONS   = false

end

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

# ** Game_Battler

#------------------------------------------------------------------------------

#  This class deals with battlers. It's used as a superclass for the Game_Actor

#  and Game_Enemy classes.

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

class Game_Battler

  #--------------------------------------------------------------------------

  # * Determine [Can't Evade] States

  #--------------------------------------------------------------------------

  alias ad_nev_gb_noevade_cant_evade? cant_evade?

  alias ad_nev_gb_noevade_ae attack_effect

  alias ad_nev_gb_noevade_se skill_effect

  alias ad_nev_gb_noevade_ie item_effect

  #--------------------------------------------------------------------------

  # * ALIASED / ATTACHED-CODE METHODS

  #--------------------------------------------------------------------------

  #--------------------------------------------------------------------------

  # * Determine [Can't Evade] States

  #--------------------------------------------------------------------------

  def cant_evade?

    #

    return true if cant_evade_flag? == true       # Exit true for custom flag

    return ad_nev_gb_noevade_cant_evade?          # Perform the original method

    #

  end

  #--------------------------------------------------------------------------

  # * Applying Normal Attack Effects

  #     attacker : battler

  #--------------------------------------------------------------------------

  def attack_effect(attacker)

    #

    enemy_evadable?(attacker)                     # Test for non-evasion enemy

    attacker_evadable?(attacker)                  # Test for non-evasion state

    weapon_evadable?(attacker)                    # Test for non-evasion weapon

    effective = ad_nev_gb_noevade_ae(attacker)    # Perform the original method

    return effective                              # Exit with effectiveness

    #

  end

  #--------------------------------------------------------------------------

  # * Apply Skill Effects

  #     user  : the one using skills (battler)

  #     skill : skill

  #--------------------------------------------------------------------------

  def skill_effect(user, skill)

    #

    skill_evadable?(skill)                        # Test for non-evasion skill

    effective = ad_nev_gb_noevade_se(user, skill) # Perform the original method

    return effective                              # Exit with effectiveness

    #

  end

  #--------------------------------------------------------------------------

  # * Application of Item Effects

  #     item : item

  #--------------------------------------------------------------------------

  def item_effect(item)

    #

    item_evadable?(item)                          # Test for non-evasion item

    effective = ad_nev_gb_noevade_ie(item)        # Perform the original method

    return effective                              # Exit with effectiveness

    #

  end

  #--------------------------------------------------------------------------

  # * NEW METHODS

  #--------------------------------------------------------------------------

  #--------------------------------------------------------------------------

  # * Determine if custom can't evade flags in use

  #--------------------------------------------------------------------------

  def cant_evade_flag?

    #

    return true if @no_ev_enemy     == true      # Exit true for custom enemy

    return true if @no_ev_attacker  == true      # Exit true for custom state

    return true if @no_ev_weapon    == true      # Exit true for custom weapon

    return true if @no_ev_skill     == true      # Exit true for custom skill

    return true if @no_ev_item      == true      # Exit true for custom item

    return false

    #

  end

  #--------------------------------------------------------------------------

  # * Get if Attacker's current state prevents execution

  #     attacker : battler

  #--------------------------------------------------------------------------

  def attacker_evadable?(attacker)

    #

    @no_ev_attacker = false                       # Set flag assuming evadable

    for id in attacker.states                     # Cycle through states

      if NoEvade::STATE_IDS.include?(id)          # If in the No-Evade list

        @no_ev_attacker = true                    # ...set flag as not evadable

      end

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Get if Enemy Attacker prevents evasion

  #     attacker : battler

  #--------------------------------------------------------------------------

  def enemy_evadable?(attacker)

    #

    @no_ev_enemy = false                          # Set flag assuming evadable

    unless attacker.is_a?(Game_Enemy)             # If the user isn't an enemy

      return                                      # ... exit the method

    end

    id = attacker.id                              # Get enemy ID

    if NoEvade::ENEMY_IDS.include?(id)            # If in the No-Evade list

      @no_ev_enemy = true                         # ...set flag as not evadable

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Get if Attack Weapon prevents evasion

  #     attacker : battler

  #--------------------------------------------------------------------------

  def weapon_evadable?(attacker)

    #

    @no_ev_weapon = false                         # Set flag assuming evadable

    if attacker.is_a?(Game_Enemy)                 # If the user is an enemy

      unless NoEvade::ENEMY_WEAPONS == true       # ... and cannot use weapons

        return                                    # ... exit the method

      end

    end

    id = attacker.weapon_id                       # Get the weapon's ID

    if NoEvade::WEAPON_IDS.include?(id)           # If in the No-Evade list

      @no_ev_weapon = true                        # ...set flag as not evadable

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Get if Skill prevents evasion

  #     skill : skill

  #--------------------------------------------------------------------------

  def skill_evadable?(skill)

    #

    @no_ev_skill = false                          # Set flag assuming evadable

    id = skill.id                                 # Get the skill's ID

    if NoEvade::SKILL_IDS.include?(id)            # If in the No-Evade list

      @no_ev_skill = true                         # ...set flag as not evadable

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Get if item prevents evasion

  #     item : item

  #--------------------------------------------------------------------------

  def item_evadable?(item)

    #

    @no_ev_item = false                           # Set flag assuming evadable

    id = item.id                                  # Get the item's ID

    if NoEvade::ITEM_IDS.include?(id)             # If in the No-Evade list

      @no_ev_item = true                          # ...set flag as not evadable

    end

    #

  end

end

Instructions

Pretty much simple instructions in the script.

Compatibility

Designed solely for RPGMaker XP.

All contents have been aliased, or had code attached to existing methods without rewrites.

Credits and Thanks

Thanks to Ace_V for another script suggestion.

Terms and Conditions

Free for use, even in commercial projects. Only due credit for myself and Ace_V who suggested a like feature is required.

Active Bound-Area Events

Sun, 08 Feb 2026 02:23:50 +0000

Active Bound-Area Events
Version: 1.0

Introduction

Utilizing the area-defining mechanics of "Expanded Encounter Areas", you can now create events that move about randomly, but only within areas which you have defined. Monsters may never leave their hunting area, guards may be forced to stay within their posts, and a throng of wild party animals might find they never leave the opulant dance floor.

Its up to you.

Screenshots

Picture a guy running into an invisible wall and taking a step backwards...

Demo

CLICK HERE

Script

FUN STUFF HERE

Code:
#==============================================================================

# ** Active Bound-Area Events

#    Add-On for Expanded Encounter Areas

#------------------------------------------------------------------------------

#    by DerVVulfman

#    version 1.0

#    02-07-2025 (MM-DD-YYYY)

#    RGSS / RMXP

#    Requires:  Expanded Encounter Areas

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

#

#  Utilizing the area-defining mechanics  of "Expanded Encounter Areas",  you

#  can now create events that move about randomly, but only within areas which 

#  you have defined. Monsters may never leave their hunting area,  guards may

#  be forced to stay  within their posts,  and a throng of wild party animals

#  might find they never leave the opulant dance floor.

#

#  Its up to you.

#

#

#------------------------------------------------------------------------------

#  

#  I will not go into details  into how to set up an 'area' where your events

#  are to be contained.  Instead, I will focus on this script and how to make

#  events that are essentially TRAPPED by the areas created with that work.

#

#  Okay, setting up an event to be STUCK in an area (or areas).

#

#  This is done  by adding comments  within the  'Event commands' window. The

#  first comment is one  that informs the script  that the event is indeed to

#  be trapped in an area (or areas).  The comment is merely one word,  and is

#  the word "EEA" by default (no quotes).  When I say its 'by default' I mean

#  you can change that word in the simple config section of ths script.

#

#  But for now, the trigger word that identifies the event as one stuck in an

#  area is "EEA". ^_^

#

#  Following this,  the second comment you add  contains the word "EEA_Areas"

#  followed by either a number or an array of numbers.  The number(s) are the

#  ID keys to the "AREA" hashes you have setup in "Expanded Encounter Areas".

#  So if you have a comment read "EEA_Areas 4", then the event is stuck with-

#  in AREA[4] in your system.   And the comment is like "EEA_Areas [5,6,9]", 

#  then your event will only be able to walk about within those three defined

#  areas. Of course, I am going to assume  there's some overlap between these

#  as the event can't very well HOP distances.

#

#  Actually, the JUMP event will work in that instance. ^_^

#

#  The last comment is more optional, but understandingly so.  It defines the

#  way the event behaves  when it tries to exit out of the area.  By default,

#  the event merely backs up (walks backwards) one tile.  Otherwise, you have

#  access to five other reactions to an attempted area border crossing.

#

#    0 = steps backwards 1 tile (default)

#    1 = steps backwards 2 tiles

#    2 = turns and walks forward 1 tile (away from border)

#    3 = turns and walks forward 2 tiles (away from border)

#    4 = Walks/Moves to the vent's origin point (may be hindered by objects)

#    5 = Appears at the event's origin point  

#

#    Options 0-3 work best when the event is still 'within' an area. If it

#    is outside an area,  these may cause the event to be stuck and unable

#    to move. Options 4&5 allow events to return to its origin despite the

#    area movement limitations.

#

#  You may neglect to add  the "EEA_Return" comment as it has a default,  but

#  you do need to add the "EEA" trigger word and the "EEA_Areas" otherwise it

#  will not finish defining the event.

#

#

#------------------------------------------------------------------------------

#  

#  Something you may not have considered.  The EEA commands  only work within

#  event pages where they are defined.  That is to say, you can make an event

#  with multiple pages, and each page can have its own set of EEA commands to

#  control what areas it may traverse, or have pages where they don't exist.

#

#  Being able to set different EEA commands or have them non-existent on some

#  pages should give you even MORE control than you might have expected!

#

#

#------------------------------------------------------------------------------

#  

#  The Configuration section (below)  is present solely so you can choose the

#  words that you use when you create your event.  Its only present for those

#  who use another language and for their convenience.  Otherwise, its hardly

#  ever going to get touched.

#

#  NOTE:   The EEA Trigger word is case sensitive,  so it must be exactly the

#          same in your event comments.  The others are case inseneitive, and

#          do not care if you use upper and/or lowercase characters.

#

#

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

#

#  COMPATABILITY:

#

#  Designed solely for RPGMaker XP and the Expanded Encounter Areas script.

#

#  All contents have been aliased, or had code attached to existing methods

#  without rewrites.

#

#

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

#

#  TERMS AND CONDITIONS

#

#  Free for use, even in commercial projects.  Only due credit for myself and

#  Ace_V who suggested a like feature is required.

#

#

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

module EncArea

  # The Expanded Encounter Area Trigger

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

  # This word needs to be read first by the system to inform the script that

  # the event is an EEA controlled event.  The word is case sensitive, so if

  # your 'replacement' for EEA has upper and lowercase characters, so too it

  # must be in your comments.

  #

    EEA_FLAG = "EEA"

  # The Expanded Areas Array

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

  # This word informs the system that it will be followed by either the ID of

  # an area defined in the "Expanded Encounter Areas" script,  or by an array 

  # filled with multiple IDs.  Unlike the EEA_Flag, it is case insensitive.

  #

    AREA_FLAG = "EEA_Areas"

  # The Expanded Areas Return Type

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

  # This word informs the system that you have chosen the manner in which the

  # event will back away and remain within the enclosed area.  Again, this is

  # also a case insensitive word.

  #

    RETURN_FLAG = "EEA_RETURn"

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

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias dervv_event_eea_init initialize

  alias dervv_event_eea_refresh refresh

  alias dervv_event_eea_update update

  #--------------------------------------------------------------------------

  # * Aliased and Attached Methods

  #--------------------------------------------------------------------------  

  #--------------------------------------------------------------------------

  # * Object Initialization

  #     map_id : map ID

  #     event  : event (RPG::Event)

  #--------------------------------------------------------------------------

  def initialize(map_id, event)

    #

    dervv_event_eea_init(map_id, event)         # Perform the original method

    #

  end

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh  

    #

    @eea_areas = []                             # Clear EEA area IDs

    @eea_return = 0                             # Reset EEA return trigger

    dervv_event_eea_refresh                     # Perform the original method

    refresh_eea_events(@list)                   # Perform checks on event

    #

  end

  #--------------------------------------------------------------------------

  # * Determine if Passable (from Game_Character)

  #     x : x-coordinate

  #     y : y-coordinate

  #     d : direction (0,2,4,6,8)

  #         * 0 = Determines if all directions are impassable (for jumping)

  #--------------------------------------------------------------------------

  def passable?(x, y, d)

    #

    eea_area_exceeded?(x, y, d)                 # Test if event exceeds area

    return super(x, y, d)                       # Exit with superclass result

    #

  end

  #--------------------------------------------------------------------------

  # * Frame Update

  #--------------------------------------------------------------------------

  def update

    #

    update_eea_event_return                     # Force return on trigger

    dervv_event_eea_update                      # Perform the original method

    #

  end

  #--------------------------------------------------------------------------

  # * Attached Methods - Direct link to Aliased Methods

  #--------------------------------------------------------------------------  

  #--------------------------------------------------------------------------

  # * Refresh (when retrieving comment commands)

  #     list : list of event commands

  #--------------------------------------------------------------------------

  def refresh_eea_events(list)

    #

    return if list.nil?                         # Exit if there's no cmd list

    #

    parameters  = []                            # Create Array for comments

    word1       = EncArea::EEA_FLAG             # Get EEA word (case sensitive)

    word2       = (EncArea::AREA_FLAG).upcase   # Get Area array word

    word3       = (EncArea::RETURN_FLAG).upcase # Get Event reaction word

    #

    # Cycle through list

    update_eea_event_return                     # Force return on trigger

    for item in list                            # Cycle through the commands

      unless [108, 408].include?(item.code)     # If it isn't a comment

        next                                    # Skip to next item

      end

      parameters.push(item.parameters[0])       # Push item into comment array

    end

    #

    return if parameters == []                  # Exit if no comments

    return unless parameters.include?(word1)    # Exit if no EEA word/flag

    #

    for param in parameters                     # Cycle through comments

      check = param.split                       # Split each comment in two

      next if check[1].nil?                     # Exit if second half empty

      #

      trigger = check[0].upcase                 # Get comment trigger

      if trigger == word2                       # If it's an area array trigger

        refresh_eea_event_area(check[1])        # Obtain area IDs for the event

      end      

      if trigger == word3                       # If it's a event return trigger

        refresh_eea_event_return(check[1])      # Obtain return for event

      end

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Determine if Encounter Area exceeded

  #     x : x-coordinate

  #     y : y-coordinate

  #     d : direction (0,2,4,6,8)

  #         * 0 = Determines if all directions are impassable (for jumping)

  #--------------------------------------------------------------------------

  def eea_area_exceeded?(x, y, d)

    #

    nx = (x+1) + (d == 6 ? 1 : d == 4 ? -1 : 0) # Get new x coords (start at 1)

    ny = (y+1) + (d == 2 ? 1 : d == 8 ? -1 : 0) # Get new y coords (start at 1)

    #

    return if @eea_areas.nil?                   # Exit on invalid areas

    return if @eea_areas == []                  # Exit if event areas is empty

    #    

    effective = false                           # Assume not in a defined area

    #    

    for area in @eea_areas                      # Cycle through event's areas

      next if area.nil?                         # Skip if area is empty

      if $game_map.eea_map_area?(nx, ny, area)  # If the event is IN the area  

        effective = true                        # Set the effective flag

      end

    end

    #

    return if effective == true                 # Exit if still in the area(s)

    #

    @eea_trigger = true                         # Set trigger - event outside!

    #

  end

  #--------------------------------------------------------------------------

  # * Frame Update (when moving the event back across the border)

  #--------------------------------------------------------------------------

  def update_eea_event_return

    #

    return unless @eea_trigger == true          # Exit unless triggered

    @eea_trigger = false                        # Clear the trigger

    eea_event_motion(@eea_return)               # Force the event to move

    #

  end

  #--------------------------------------------------------------------------

  # * New Methods

  #--------------------------------------------------------------------------  

  #--------------------------------------------------------------------------

  # * Refresh event areas defined

  #     value : area list value

  #--------------------------------------------------------------------------

  def refresh_eea_event_area(value)

    #

    val = eval(value)                           # Get evaluated value

    #

    if val.is_a?(Array)                         # If it is an array

      @eea_areas = val                          # Merely accept the value

    end

    if val.is_a?(Integer)                       # If it is a single integer

      @eea_areas = [val]                        # Set the value in an array

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Refresh event return condition

  #     value : movement return value

  #--------------------------------------------------------------------------

  def refresh_eea_event_return(value)

    #

    @eea_return =  eval(value).to_i             # Set return to evaluated value

    @eea_return = 0 if @eea_return < 0          # Return is no lower than 0

    @eea_return = 5 if @eea_return > 5          # Return is no higher than 5

    #

  end

  #--------------------------------------------------------------------------

  # * Perform event movtion based on Encounter area

  #     value : movement return value

  #--------------------------------------------------------------------------

  def eea_event_motion(value)

    #

    # NOTE: Required 1 additional movement to counter attempted crossing.

    #

    case value                                    # Branch on move value

    when 1 ; eea_b ; eea_b; eea_b                 # Step backwards twice

    when 2 ; turn_180 ; eea_f ; eea_f             # Turn & step forward

    when 3 ; turn_180 ; eea_f ; eea_f; eea_f      # Turn & two steps forward

    when 4 ; @x, @y = @event.x, @event.y          # Move to origin

    when 5 ; moveto(@event.x, @event.y)           # Appear at origin

    else ;   eea_b ; eea_b                        # Step backwards

    end

    #

  end

  #--------------------------------------------------------------------------

  # * Shortcut to Game_Character: move_backward

  #--------------------------------------------------------------------------

  def eea_b

    move_backward

  end

  #--------------------------------------------------------------------------

  # * Shortcut to Game_Character: move_forward

  #--------------------------------------------------------------------------

  def eea_f

    move_forward

  end

end

Instructions

Plenty, and in the script. But most of the work is in the parent script this requires.

Compatibility

Designed solely for RPGMaker XP and the Expanded Encounter Areas script.

Credits and Thanks

Gotta thank Ace_V for giving me the idea.

Terms and Conditions

Free for use, even in commercial projects. Only due credit for myself and Ace_V who suggested a like feature is required.

BattleAktionFX XP

Sat, 27 Dec 2025 12:55:45 +0000

BattleAktionFX XP

by Kyonides

Introduction

After reading lots of stuff on Discord on some Follow Up Skill script for VX ACE, I thought XP badly needed to get something like that. This is how this script came into existence!

Currently, there are 4 options available:

:repeat for repeating the skill cast a few moments ago.
:random_skill for picking a skill from the current actor's or enemy's list of available skills / action.
:foe_skill for choosing a skill from an opponent's list of available skills / actions.
Some predefined skill ID - it might fail if the battler doesn't know it.
nil - it means nothing in Latin.

To add a new skill to the list, follow this example here:

Code:
SKILL_FX[57] = [:repeat, :random_skill]

57 would stand for the actual skill ID.

During gameplay, the script will pick one of those options randomly, unless there's just 0 or 1 there.

And yes, enemies might escape or guard or do nothing if they got no valid action to perform at that point.

The Script

Code:
# * BattleAktionFX XP * #

#   Scripter : Kyonides

#   v0.5.0 - 2025-12-29

# Let your actors or troopers get an extra action for certain skills

# IF AND ONLY IF they meet some of the predefined criteria.

# Warning!

# Enemies using a skill's effect might escape or guard if they've got

# no available action left!

# Available Options:

# :repeat, :random_skill, :foe_skill, a specific skill ID, nil

module BAktionFX

  MAX_EXTRA_ACTIONS = 1

  SKILL_FX = {} # Please leave this line alone!

  SKILL_FX.default = [] # Please leave this line alone!

  # [Skill ID] = [Option1, etc.]

  SKILL_FX[57] = [:repeat, :random_skill]

  extend self

  def set_make_targets(set_targets)

    @set_targets = set_targets

  end

  def skip?

    MAX_EXTRA_ACTIONS == @extra_actions or @skill_hits == 0

  end

  def process_skill(battler, skill_id)

    if skip?

      clear

      return

    end

    action = battler.current_action

    fx = SKILL_FX[skill_id]

    slots = fx.size

    fx = fx[rand(slots)]

    case fx

    when nil

      clear

      return

    when :repeat

      kind, basic, fx = action.data

    when :random_skill

      kind, basic, fx = battler.find_extra_action

    when :foe_skill

      kind, basic, fx = battler.find_foe_action

    end

    skill = $data_skills[fx]

    unless skill

      clear

      return

    end

    @set_targets.call(skill.scope)

    @targets = @targets.call.flatten

    if @targets.empty?

      clear

      return

    end

    @targets = nil

    @extra_actions += 1

    @skill_hits = 0

    action.set(kind, basic, fx)

    true

  end

  def clear

    @skill_hits = @extra_actions = 0

  end

  attr_accessor :extra_actions, :skill_hits, :targets

end

class Game_BattleAction

  def data

    [@kind, @basic, @skill_id]

  end

  def set(akind, abasic, askill_id)

    @kind = akind

    @basic = abasic

    @skill_id = askill_id

  end

end

class Game_Battler

  alias :kyon_btl_akt_fx_gm_btlr_sk_fx :skill_effect

  def skill_effect(user, skill)

    result = kyon_btl_akt_fx_gm_btlr_sk_fx(user, skill)

    BAktionFX.skill_hits += 1 if result and @damage.is_a?(Integer)

    result

  end

  def set_opponent_action(foes)

    return [0, rand(3) + 1, 0] if foes.empty?

    total = foes.size

    foe = foes[rand(total)]

    foe.find_extra_action

  end

  def skill_can_use_extra?(skill)

    return false if dead? or skill.sp_cost > self.sp

    return false if skill.atk_f == 0 and self.restriction == 1

    skill.occasion < 2 and rand(100) < 50

  end

  attr_accessor :extra_action

end

class Game_Actor

  def find_extra_action

    skills_found = @skills.select {|sid| skill_can_use?(sid) }

    total = skills_found.size

    skill_id = skills_found[rand(total)]

    [1, 0, skill_id]

  end

  def find_foe_action

    foes = $game_troop.enemies.select {|e| e.exist? }

    set_opponent_action(foes)

  end

end

class Game_Enemy

  def find_extra_action

    return [0, rand(3) + 1, 0] unless movable?

    found_actions = []

    for action in self.actions

      n = $game_temp.battle_turn

      a = action.condition_turn_a

      b = action.condition_turn_b

      if (b == 0 and n != a) or

         (b > 0 and (n < 1 or n < a or n % b != a % b))

        next

      end

      if self.hp * 100.0 / self.maxhp > action.condition_hp

        next

      end

      if $game_party.max_level < action.condition_level

        next

      end

      switch_id = action.condition_switch_id

      if switch_id > 0 and !$game_switches[switch_id]

        next

      end

      found_actions << action

    end

    return [] if found_actions.empty?

    total = found_actions.size

    action = found_actions[rand(total)]

    action.data

  end

  def find_foe_action

    foes = $game_party.actors.select {|e| e.exist? }

    set_opponent_action(foes)

  end

end

class Scene_Battle

  alias :kyon_btl_akt_fx_scn_btl_stt_ph4 :start_phase4

  alias :kyon_btl_akt_fx_scn_btl_mk_sk_act_res :make_skill_action_result

  alias :kyon_btl_akt_fx_scn_btl_up_ph4_st6 :update_phase4_step6

  alias :kyon_btl_akt_fx_scn_btl_btl_end :battle_end

  def start_phase4

    BAktionFX.clear

    @used_skill = nil

    kyon_btl_akt_fx_scn_btl_stt_ph4

  end

  def make_skill_action_result

    if @active_battler.extra_action

      make_extra_skill_action_result

    else

      kyon_btl_akt_fx_scn_btl_mk_sk_act_res

    end

    @used_skill = @phase4_step != 1

  end

  def make_extra_skill_action_result

    @skill = $data_skills[@active_battler.current_action.skill_id]

    unless @active_battler.current_action.forcing

      unless @active_battler.skill_can_use_extra?(@skill)

        $game_temp.forcing_battler = nil

        @phase4_step = 1

        return

      end

    end

    @active_battler.sp -= @skill.sp_cost

    @status_window.refresh

    @help_window.set_text(@skill.name, 1)

    @animation1_id = @skill.animation1_id

    @animation2_id = @skill.animation2_id

    @common_event_id = @skill.common_event_id

    set_target_battlers(@skill.scope)

    for target in @target_battlers

      target.skill_effect(@active_battler, @skill)

    end

  end

  def update_phase4_step6

    kyon_btl_akt_fx_scn_btl_up_ph4_st6

    @active_battler.extra_action = nil

    return unless @used_skill

    @target_battlers = []

    BAktionFX.targets = @target_battlers

    unless @embedded

      BAktionFX.set_make_targets(method(:set_target_battlers))

      @embedded = true

    end

    if BAktionFX.process_skill(@active_battler, @skill.id)

      @action_battlers.unshift @active_battler 

      @active_battler.extra_action = true

    end

    @target_battlers = []

    @used_skill = nil

  end

  def battle_end(result)

    BAktionFX.clear

    kyon_btl_akt_fx_scn_btl_btl_end(result)

  end

end

Terms & Conditions

Free as in beer.
Please include me in your game credits.
That's it!

KReviveOnce XP

Wed, 10 Dec 2025 17:39:06 +0000

KReviveOnce XP

by Kyonides

Introduction

Sometimes your heroes deserve a second chance to defeat that terrible mega boss. Or you might simply think that their story should not end because they were just too weak after an epic battle as to also worry about facing a couple of slimes right away.

No matter what your excuse might be, now your heroes can be automatically revived once!

Just set a specific state ID and the HP percentage they will recover and that's it!

Of course, if a given hero dies without having that state listed at that critical moment, it's game over for him or her!

The Script

Code:
# * KReviveOnce XP * #

#  Scripter : Kyonides

#  2025-12-10

# Let your heroes revive ONCE if they got a very specific state before

# they met their premature demises.

module KRevive

  ONCE_STATE_ID = 25

  ONCE_STATE_PERC = 25

end

class Game_Battler

  alias :kyon_revive_once_gm_btlr_remove_state :remove_state

  def check_revive_once(state_id)

    @can_revive = (KRevive::ONCE_STATE_ID == state_id and state?(state_id))

  end

  def remove_state(state_id, force=false)

    check_revive_once(state_id)

    kyon_revive_once_gm_btlr_remove_state(state_id, force)

    apply_revive_once

  end

  def apply_revive_once

    if @can_revive and !state?(KRevive::ONCE_STATE_ID) and @hp < 2

      @states.delete(1)

      @hp = maxhp * KRevive::ONCE_STATE_PERC

    end

    @can_revive = nil

  end

end

Terms & Conditions

Free as in beer.
Include me in your game credits.
That's it!

Hex Colors RG

Tue, 18 Nov 2025 07:02:54 +0000

Hex Colors RG

by Kyonides

Introduction

I'm back to leave you another scriptlet that will allow you to use hex colors in your windows and sprites with ease.

This code will work on RMXP, RMVX and even RMVX ACE!

Just use it like this:

For Windows:

Code:
self.contents.font.color = hex_color("FF00FF")

For Sprites:

Code:
self.bitmap.font.color = hex_color("FF00FF")

In this particular case, your text will become purple-ish!

You can also add 2 extra characters to set the alpha value of your custom color manually.

In both cases you can add the # pound sign at the beginning of the string, but it's not mandatory.

The Script

Code:
# * Hex Colors RG * # 

#  Scripter : Kyonides

#  2025-11-18

module Hex

  def hex_color(hex)

    digits = hex.size

    hex.sub!("#", "")

    red = hex[0, 2].to_i(16)

    green = hex[2, 2].to_i(16)

    blue = hex[4, 2].to_i(16)

    alpha = digits == 8 ? hex[6, 2] : 255

    Color.new(red, green, blue, alpha)

  end

end

class Window_Base

  include Hex

end

class Sprite

  include Hex

end

Terms & Conditions

It's free as in beer. That's all you need to know.