Save-Point - RPGMaker VX/VXAce (RGSS2/3) Engines

SCREEN SIZE for RMVXAce

Mon, 13 Apr 2026 18:41:49 +0000

SCREEN SIZE for RMVXAce
Version: 1.0

Introduction
I had been tinkering with the manipulation of the available gaming area for RPGMaker XP games. And I did well with a barebones script that did not require the use of any external .DLL outside of Win32 manipulations, a script based upon the work of Selwyn (formerly Squall).

This specific script is an adapation of my XP version, but altered for use with RPGMaker VX Ace. Simpler in design due to updates made in the Viewport class and Weather system.

The Game.Exe's Fullscreen mode reverts to a fixed 640x480 resolution so the [ALT]+[ENTER] key combination is disabled. Fullscreen mode is literally disabled by intent with this setup.

Screenshots
None.

Script

Instruction/Header

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

# ** SCREEN SIZE for VXACE

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

#    Version 1.0

#    By DerVVulfman

#    04-13-2026 (MM-DD-YYYY)

#    RGSS3 / RPGMaker VX Ace

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

#

#  INTRODUCTION:

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

#  I had been tinkering with the manipulation of the available gaming area for

#  RPGMaker XP games.  And I did well with a barebones script that did not re-

#  quire the use of any external .DLL outside of Win32 manipulations, a script

#  based upon the work of Selwyn (formerly Squall).

#

#  This specific script is an adapation of my XP version,  but altered for use

#  with RPGMaker VX Ace. Simpler in design due to updates made in the Viewport

#  class and Weather system.

#

#  ALERT: The Game.Exe's Fullscreen mode reverts to a fixed 640x480 resolution

#         so the [ALT]+[ENTER] key combination is disabled. Fullscreen mode is

#         literally disabled by intent with this setup.

#

#

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

#

#  INSTRUCTIONS:

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

#  I would hope this is clear.  It is mostly plug-and-play, only requiring you

#  to set some configurable values within the ScrnSize module  at the very top

#  of the actual system code.  And all the variable options have detailed des-

#  criptions of what is being set.

#

#  NOTE: If you are using  other scripts that perform alterations  to the size

#        of screen contents (YanFly's Core as an example), ensure both are set

#        to the same resolution.

#

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

#

#  COMPATABILITY:

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

#  Designed for RPGMaker VXAce.

#

#  Alters the screen size, so other scripts that adjust viewport settings will

#  need to be likewise altered.

#

#

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

#

#  CREDITS AND THANKS:

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

#  The very basics of this system  comes from the DLL-free version of Selwyn's

#  resolution script. 

#

#  And thanks goes to ViperDamascus  who was looking for a script  to increase 

#  VXAce's screen size beyond the 640x480 maximum.

#

#

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

#

#  TERMS and CONDITIONS:

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

#  Free for use, even in commercial scripts. However, I require due credit for

#  myself, Selwyn who crafted the basics, and ViperDamascus for the request.

#

#

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

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

# ** ScrnSize

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

#  This module handles the adjustable screen size for games that utilize

#  resolution scripts to alter game window dimensions.

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

module ScrnSize

  # GAME SCREEN RESOLUTION

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

  # The absolute necessity... defining the size of the visible area of your

  # game on the screen. You will see below some dimensions tested, and then

  # commented out. Even reducing the size to older RPGMaker 2000 scale exe-

  # cuted just fine.

  # < -- IT IS RECOMMENDED THAT THE DEFINED VALUES BE MULTIPLES OF 32! -- >

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

  #

    Width     = 1280      # Screen area width in pixels

    Height    = 736       # Screen area height in pixels.

#    Width     = 640

#    Height    = 480

#    Width     = 320

#    Height    = 200

  # GAME INI NAMING

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

  # A necessity if you are renaming the Game Executable (eg Game.exe). When

  # your game/project is run, it looks for its requisite .ini file which it

  # assumes to have the same name as its executable. Many leave the name of

  # the executable alone. But if you choose to rename Game.exe to Trek.exe,

  # it will search for Trek.ini. And if the assumed ini does not exist, the

  # game will fail.

  #

  # The resolution changing system relies upon retriving the windows handle

  # for the game when it executes.  And for this, it needs the current name

  # of the Game's INI file.  So if you do change the name of the executable

  # (and thus the name of the INI), it needs the name defined below.

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

  #

    INI_Name  = 'Game.ini'

  # GAME EXECUTION SPEED

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

  # This is an old trick,  changing the speed of the executable to make the

  # game itself run faster.  RPGMaker XP was set to a default 40 frames per

  # second while RPGMaker VX and VXAce to a native 60 frames per second.

  #

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

  # Changing this value affects all...  script/code speed,  character speed

  # in the fieldmap, battle animations, and the like.

  #

  # RANGE: 10-120. VXAce will not exceed 120fps nor go slower than 10.

  #

  # NOTE: Smooth mode refreshes graphics ever frame based on this value.

  #       Normal mode only refreshes every other frame.

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

  #

    Graphics.frame_rate = 40  

end

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

# ●● Resolution

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

#  This module uses the Win32API to connect to the RPGMaker XP game window and

#  re-sizes the window based on the game developer's preferences.

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

module Resolution

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

  # ● instance variables

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

  attr_reader :state

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

  # ● initialize

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

  def initialize

    # Acquire desired window settings from configuration

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

    @reswidth   = ScrnSize::Width

    @resheight  = ScrnSize::Height

    # Set instance variables for calling basic Win32 functions

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

    ini     = Win32API.new('kernel32', 'GetPrivateProfileString','PPPPLP', 'L')

    title   = "\0" * 256

    # Get Window Title

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

    ini.call('Game', 'Title', '', title, 256, '.\\' + ScrnSize::INI_Name)

    title.delete!("\0")

    # Acquire Metrics from the Win32 API

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

    @window       = Win32API.new('user32', 'FindWindow',       'PP', 

                    'I').call("RGSS Player", title)

    @set_win_long = Win32API.new('user32', 'SetWindowLong',    'LIL', 'L')

    @set_win_pos  = Win32API.new('user32', 'SetWindowPos',     'LLIIIII', 'I')

    @gsm          = Win32API.new('user32', 'GetSystemMetrics', 'I', 'I')

    @gcr          = Win32API.new('user32', 'GetClientRect',    'LP', 'I')

    @kbe          = Win32API.new('user32', 'keybd_event',      'LLLL', '')

    @gaks         = Win32API.new('user32', 'GetAsyncKeyState', 'L', 'I')

    # Render message and exit if size is not supported

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

    @default_size = self.size

    if size[0] < @reswidth or size[1] < @resheight

      print("\"#{title}\" requires a minimum screen resolution " +

            "of [#{@reswidth} x #{@resheight}]\r\n\r\n" +

            "\tYour Resolution: [#{@default_size[0]} x #{@default_size[1]}]")

      exit

    end

    # Apply Resolution Change

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

    @state = "default"

    self.default

  end

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

  # ● fullscreen

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

  def fullscreen

    #

    @default_size = size

    @set_win_long.call(@window, -16, 0x14000000)

    @set_win_pos.call(@window, -1, 0, 0, (@reswidth+2), (@resheight+2), 64)

    @state = "fullscreen"

    #

  end

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

  # ● default

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

  def default

    #

    x = @default_size[0] / 2 - ((@reswidth/2) + 3)

    y = @default_size[1] / 2 - ((@resheight/2) + 8)

    @set_win_long.call(@window, -16, 0x14CA0000)

    @set_win_pos.call(@window, 0, x, y, (@reswidth+8), (@resheight+27), 0)

    @state = "default"

    #

  end

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

  # ● trigger?(key)

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

  def trigger?(key)

    #

    return @gaks.call(key) & 0x01 == 1

    #

  end

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

  # ● private

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

  private :fullscreen

  private :default

  private :trigger?

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

  # ● size

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

  def size

    #

    width   = @gsm.call(0)

    height  = @gsm.call(1)

    return width, height

    #

  end

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

  # ● change

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

  def change

    #

    if @state == "default"

      self.fullscreen

    else

      self.default

    end

    #

  end

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

  # ● update

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

  def update

    #

    if trigger?(121) # F10

      self.change

    end

    if Input.trigger?(Input::ALT) or Input.press?(Input::ALT)

      @kbe.call(18, 0, 2, 0)

    end

    #

  end

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

  # ● module functions

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

  module_function :initialize

  module_function :fullscreen

  module_function :default

  module_function :trigger?

  module_function :size

  module_function :change

  module_function :update

  #

end

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

# ●● Input

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

#  A class that handles input data from a gamepad or keyboard.

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

class << Input

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

  # ● Alias Listings (with F12 Stack prevention)

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

  alias res_update update unless $@

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

  # ● Input.update

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

  def Input.update

    # Perform the original call

    res_update

    # Update the Resolution

    Resolution.update

  end

end

# Execute at start

Resolution.initialize

Instructions
Plenty, and in the script.

Compatibility
Designed for RPGMaker XP

Alters the screen size, so other scripts that adjust viewport settings will need to be likewise altered.

Credits and Thanks
The very basics of this system comes from the DLL-free version of Selwyn's resolution script.

And thanks goes to ViperDamascus who was looking for a script to increase VXAce's screen size beyond the 640x480 maximum.

Terms and Conditions
Free for use, even in commercial scripts. However, I require due credit for myself, Selwyn who crafted the basics, and ViperDamascus for the request.

Error reporting extension!

Mon, 16 Mar 2026 08:59:15 +0000

Here is a handy script I made a while ago to give more detailed error reports and print them to the console! It gives a full trace of where the error happened and the last called functions so you know what the problem might be! Has some limitations. Sometimes the report is too big for the little popup and it will be blank, but it should show the error in the console! Also doesn't properly trace errors inside events, so that might be something to add later.

Oh! And you can use "Error_Handler.do_trace()" to print a backtrace to the console in scripts whenever you want for debugging too!

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

# * Error handling functions.

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

module Error_Handler

  def self.script_names

    unless @script_names

      @script_names = load_data('Data/Scripts.rvdata2')

      @script_names.collect! {|script|  script[1]  }

    end

    @script_names

  end

  def self.do_backtrace(error)

    backtrace = self.parse_trace(error.backtrace)

    error_line = backtrace.first

    backtrace[0] = ''

    return error_line + ": " + error.message + " (#{error.class})" + backtrace.join("\n\tfrom ") + "\n"

  end

  def self.parse_trace(trace)

    out = []

    trace.each_with_index do |line,i|

      if line =~ /{(.*)}(.*)/

        out << (script_names[$1.to_i] + $2)

      elsif line.start_with?(':1:')

        break

      else

        out << line

      end

    end

    out

  end

  def trace_me

    begin

      raise

    rescue => exception

      puts trace = Error_Handler.do_backtrace(exception)

    end

  end

end

alias rgss_main_without_rescue rgss_main

def rgss_main(&block)

  begin

    rgss_main_without_rescue do

      begin

        block.call

      rescue SystemExit

        exit

      rescue Exception => error

        trace = Error_Handler.do_backtrace(error)

        print(trace)

        raise(error.class, trace, [error.backtrace.first])

      end

    end

  end

end

Hope it's helpful!

KReviveOnce VX

Wed, 10 Dec 2025 17:49:13 +0000

KReviveOnce VX

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 VX * #

#   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)

    check_revive_once(state_id)

    kyon_revive_once_gm_btlr_remove_state(state_id)

    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 = false

  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:03:31 +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.

Ekuipment Points VX

Thu, 06 Nov 2025 07:05:34 +0000

Ekuipment Points VX

by Kyonides

Introduction

Limit the type of weapons or armor pieces your heroes will be able to equip!
If your heroes want to replace their equipment, they better earn enough EP first!
Another way to explain it would be to call it an equipment weight script.

The script lets you set the default and custom EP the actor will start with. The same is valid for weapons and pieces of armor.
Actors can also gain more EP by leveling up.

Inside the EkuipPoints module you can find the WEAPON_POINTS, ARMOR_POINTS, ACTOR_POINTS & the ACTOR_LEVEL_POINTS constants that will let you customize the EP earned by actors and the EP costs of their equipment.

You can also change the X & Y coordinates of windows or EP labels at will.

NOTES

Actors have no note boxes. This is why you need to depend on the ACTOR_POINTS & ACTOR_LEVEL_POINTS constants to set their EP accordingly.
To open the equipment window in battle, during the actor's command phase, press the RM's X button. Normally, it's linked to your A key on the keyboard.

Screenshots

The Script

Code:
# * Ekuipment Points VX - No Shield Edition * #

#   Scripter : Kyonides

#   v1.2.6 - 2025-11-12

# Limit the type of weapons or armor pieces your heroes will be able to equip!

# If heroes want to replace their equipment, they better earn enough EP first!

# Note Tag:  where n is a positive number.

# * Optional Script Calls * #

# Block a given actor's change equipment feature, especially useful in battle:

#  boolean stands for true OR false only.

#   $game_actors[ActorID].block_equip_change = boolean

#   $game_party.members[Index].block_equip_change = boolean

# Block the party's change equipment feature at once:

#   $game_party.block_equip_change = boolean

# Increase a given actor's equipment points:

#   $game_actors[ActorID].ep_plus += Number

#   $game_party.members[Index].ep_plus += Number

module EkuipPoints

  LABEL = "EP"

  LABEL_LENGTH = { :status => 1, :ep_stats => 1 }

  LABEL_LENGTH.default = 2

  EP_LABEL_COLOR = [40, 242, 254] # [R,G,B]

  GAUGE_COLOR1   = [255, 180, 60] # [R,G,B]

  GAUGE_COLOR2   = [180, 255, 60] # [R,G,B]

  EP_COST_X = 170

  EP_STATUS_XY_WH    = [192, 122, 128, 6]

  ACTOR_EP_WIN_XY_WH = [0, 280, 144, 56]

  BATTLE_EQUIP_WIN_XY  = [80, 288]

  ACTOR_STATS_WIN_OPA  = 255

  BATTLE_EQUIP_WIN_OPA = 255

  ACTOR_STATS_WIN_BACK_OPA  = 255

  BATTLE_EQUIP_WIN_BACK_OPA = 255

  EQUIP_BASE_POINTS = 1

  # Alternate Armor Types Settings - Leave Empty If Not Needed

  # 1 - Shield

  # 2 - Helmet

  # 3 - Body Armor

  # 4 - Accessory

  ARMOR_TYPES = [3, 4, 4, 4]

  ACTOR_POINTS = {}

  ACTOR_POINTS.default = 4

  # [ActorID] = BasePoints

  ACTOR_POINTS[1] = 6

  ACTOR_POINTS[2] = 7

  ACTOR_LEVEL_POINTS = {}

  ACTOR_LEVEL_POINTS.default = { :levels => 10, :ep => 1 }

  # [ActorID] = { :levels => LevelsNeeded, :ep => ExtraPoints }

  ACTOR_LEVEL_POINTS[1] = { :levels => 8, :ep => 2 }

end

module RPG

  class BaseItem

    BASE_EP = EkuipPoints::EQUIP_BASE_POINTS

    def note_ep

      @note[/
      $1 ? $1.to_i : BASE_EP

    end

    def ep_cost

      @ep_cost ||= note_ep

    end

  end

  class Equipment

    def ep_cost

      0

    end

  end

end

module EkuipPoints

  module ItemList

    def draw_item_name(item, rx, ry, enabled=true)

      return unless item

      super

      rect = item_rect(index)

      rect.x = rx

      rect.y = ry

      rect.width -= rx

      f = contents.font

      f.color = ep_color

      f.color.alpha = 160 unless enabled

      number = sprintf("%2d", item.ep_cost)

      contents.draw_text(rect, number, 2)

    end

  end

end

class Game_Actor

  alias :kyon_ekuip_points_gm_act_stp :setup

  alias :kyon_ekuip_points_gm_act_lvl_up :level_up

  alias :kyon_ekuip_points_gm_act_lvl_dn :level_down

  def setup(actor_id)

    kyon_ekuip_points_gm_act_stp(actor_id)

    @armor1_id = actor.armor3_id

    @armor3_id = 0

    @maxep_base = EkuipPoints::ACTOR_POINTS[actor_id]

    hash = EkuipPoints::ACTOR_LEVEL_POINTS[actor_id]

    @base_ep_levels = hash[:levels]

    @base_level_ep = hash[:ep]

    @ep_plus = 0

    calc_level_ep

  end

  def calc_level_ep

    @level_ep = @level / @base_ep_levels * @base_level_ep

  end

  def level_up

    kyon_ekuip_points_gm_act_lvl_up

    calc_level_ep

  end

  def level_down

    kyon_ekuip_points_gm_act_lvl_dn

    calc_level_ep

  end

  def maxep

    @maxep_base + @level_ep + @ep_plus

  end

  def ep_used

    list = equips.compact

    list.inject(0) {|total, item| total + item.ep_cost }

  end

  def ep_left

    self.maxep - self.ep_used

  end

  def enough_ep?(equip_type, item)

    return true unless item

    equipment = equips[equip_type] || RPG::Equipment.new

    used = self.ep_used - equipment.ep_cost

    return true if used == 0

    used += item.ep_cost

    self.maxep >= used

  end

  attr_accessor :ep_plus, :block_equip_change

end

class Game_Party

  def block_equip_change=(state)

    members.each {|actor| actor.block_equip_change = state }

  end

end

class Window_Base

  def ep_color

    @ep_color ||= Color.new(*EkuipPoints::EP_LABEL_COLOR)

  end

  def ep_gauge_color1

    @ep_gauge_color1 ||= Color.new(*EkuipPoints::GAUGE_COLOR1)

  end

  def ep_gauge_color2

    @ep_gauge_color2 ||= Color.new(*EkuipPoints::GAUGE_COLOR2)

  end

  def draw_ep_left(actor, lx, ly, lw, lh=4, large=nil)

    left = actor.ep_left

    gw = lw * left / actor.maxep

    gc1 = ep_gauge_color1

    gc2 = ep_gauge_color2

    c = self.contents

    c.fill_rect(lx, ly + WLH - lh - 2, lw, lh, gauge_back_color)

    c.gradient_fill_rect(lx, ly + WLH - lh - 2, gw, lh, gc1, gc2)

    c.font.color = system_color

    label = EkuipPoints::LABEL

    length = EkuipPoints::LABEL_LENGTH[class_type]

    label = label[0, length]

    c.draw_text(lx, ly, lw, WLH, label)

    c.font.color = normal_color

    if large

      c.draw_text(lx, ly, lw / 2 + 4, WLH, left.to_s, 2)

      c.draw_text(lx, ly, lw / 2 + 16, WLH, "/", 2)

      c.draw_text(lx, ly, lw, WLH, actor.maxep.to_s, 2)

    else

      c.draw_text(lx, ly, lw, WLH, left.to_s, 2)

    end

  end

end

class Window_MenuStatus

  def refresh

    self.contents.clear

    @item_max = $game_party.members.size

    $game_party.members.each {|actor| draw_actor_data(actor) }

  end

  def draw_actor_data(actor)

    draw_actor_face(actor, 2, actor.index * 96 + 2, 92)

    dx = 104

    dy = actor.index * 96 + WLH / 2

    draw_actor_name(actor, dx, dy)

    draw_actor_class(actor, dx + 120, dy)

    draw_actor_level(actor, dx, dy + WLH * 1)

    draw_ep_left(actor, dx + 60, dy + WLH * 1, 50)

    draw_actor_state(actor, dx, dy + WLH * 2)

    draw_actor_hp(actor, dx + 120, dy + WLH * 1)

    draw_actor_mp(actor, dx + 120, dy + WLH * 2)

  end

  def class_type

    :menu_status

  end

end

class Window_Equip

  include EkuipPoints::ItemList

  def update

    last_index = @index

    super

    if @index != last_index

      @item_window.equip_type = @index

    end

  end

  def refresh

    self.contents.clear

    @data = []

    for item in @actor.equips do @data.push(item) end

    @item_max = @data.size

    self.contents.font.color = system_color

    if @actor.two_swords_style

      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab.weapon1)

      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab.weapon2)

    else

      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab.weapon)

      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab.armor3)

    end

    self.contents.draw_text(4, WLH * 2, 92, WLH, Vocab.armor4)

    self.contents.draw_text(4, WLH * 3, 92, WLH, Vocab.armor4)

    self.contents.draw_text(4, WLH * 4, 92, WLH, Vocab.armor4)

    draw_item_name(@data[0], 92, WLH * 0)

    draw_item_name(@data[1], 92, WLH * 1)

    draw_item_name(@data[2], 92, WLH * 2)

    draw_item_name(@data[3], 92, WLH * 3)

    draw_item_name(@data[4], 92, WLH * 4)

  end

  attr_writer :item_window

end

class Window_EquipMod < Window_Selectable

  include EkuipPoints::ItemList

  def initialize(wx, wy, actor)

    super(wx, wy, 336, WLH * 4 + 32)

    self.z = 1000

    self.opacity = EkuipPoints::BATTLE_EQUIP_WIN_OPA

    self.back_opacity = EkuipPoints::BATTLE_EQUIP_WIN_BACK_OPA

    @actor = actor

    refresh

    self.index = 0

  end

  def row_max

    5

  end

  def item

    @data[@index]

  end

  def refresh

    self.contents.clear

    @data = []

    @actor.equips.each {|item| @data << item }

    @item_max = @data.size

    self.contents.font.color = system_color

    if @actor.two_swords_style

      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab.weapon1)

      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab.weapon2)

    else

      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab.weapon)

      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab.armor3)

    end

    self.contents.draw_text(4, WLH * 2, 92, WLH, Vocab.armor4)

    self.contents.draw_text(4, WLH * 3, 92, WLH, Vocab.armor4)

    self.contents.draw_text(4, WLH * 4, 92, WLH, Vocab.armor4)

    draw_item_name(@data[0], 92, WLH * 0)

    draw_item_name(@data[1], 92, WLH * 1)

    draw_item_name(@data[2], 92, WLH * 2)

    draw_item_name(@data[3], 92, WLH * 3)

    draw_item_name(@data[4], 92, WLH * 4)

  end

  def update_help

    @help_window.set_text(item ? item.description : "")

  end

end

class Window_EquipItem

  EQUIP_TYPES = [0] + EkuipPoints::ARMOR_TYPES

  alias :kyon_ekuip_points_win_eqpitm_init :initialize

  alias :kyon_ekuip_points_win_eqpitm_refr :refresh

  def initialize(wx, wy, width, height, actor, equip_type)

    @row_index = equip_type

    kyon_ekuip_points_win_eqpitm_init(wx, wy, width, height, actor, equip_type)

    self.index = -1

  end

  def refresh

    @has_armor_types ||= EQUIP_TYPES.size > 1

    kyon_ekuip_points_win_eqpitm_refr

  end

  def reset_index

    self.index = 0 if @index < 0

  end

  def enable?(item)

    @actor.enough_ep?(@row_index, item)

  end

  def equip_type=(type)

    @row_index = type

    type = 0 if @actor.two_swords_style && type == 1

    type = EQUIP_TYPES[type] if type > 0 and EQUIP_TYPES.size > 1

    @equip_type = type

    refresh

  end

  def draw_item(index)

    rect = item_rect(index)

    c = self.contents

    c.clear_rect(rect)

    item = @data[index]

    return unless item

    number = $game_party.item_number(item)

    enabled = enable?(item)

    rect.width -= 4

    draw_item_name(item, rect.x, rect.y, enabled)

    c.draw_text(rect, sprintf(":%2d", number), 2)

    f = c.font

    f.color = ep_color

    f.color.alpha = 160 unless enabled

    rect.x += EkuipPoints::EP_COST_X

    rect.width = 40

    number = item.ep_cost

    c.draw_text(rect, sprintf("%2d", number), 2)

  end

end

class Window_EquipStatus

  alias :kyon_ekuip_points_win_eqpstts_ref :refresh

  def refresh

    kyon_ekuip_points_win_eqpstts_ref

    draw_ep_left(@actor, 122, 0, 50)

  end

  def class_type

    :equip_status

  end

end

class Window_Status

  alias :kyon_ekuip_points_win_stts_drw_bsc_info :draw_basic_info

  def draw_basic_info(dx, dy)

    kyon_ekuip_points_win_stts_drw_bsc_info(dx, dy)

    ex, ey, ew, eh = EkuipPoints::EP_STATUS_XY_WH

    draw_ep_left(@actor, dx + ex, dy + ey, ew, eh, true)

  end

  def class_type

    :status

  end

end

module EkuipPoints

  class ActorStatsWindow < Window_Base

    def initialize(actor)

      super(*ACTOR_EP_WIN_XY_WH)

      self.opacity = ACTOR_STATS_WIN_OPA

      self.back_opacity = ACTOR_STATS_WIN_BACK_OPA

      self.z = 2000

      @actor = actor

      @hw = self.contents.width / 2

      refresh

    end

    def refresh

      self.contents.clear

      draw_actor_name(@actor, 0, 0)

      draw_ep_left(@actor, @hw, 0, @hw, 4)

    end

    def class_type

      :ep_stats

    end

  end

end

class Scene_Equip

  alias :kyon_ekuip_points_scn_eqp_stt :start

  alias :kyon_ekuip_points_scn_eqp_up_eqp_sel :update_equip_selection

  def start

    kyon_ekuip_points_scn_eqp_stt

    @equip_window.item_window = @item_window

  end

  def create_item_windows

    types = Window_EquipItem::EQUIP_TYPES

    @item_window = Window_EquipItem.new(0, 208, 544, 208, @actor, 0)

    @item_window.help_window = @help_window

    @item_window.active = false

    @item_window.index = -1

    @item_windows = [@item_window]

  end

  def update

    super

    update_menu_background

    @help_window.update

    update_status_window

    if @equip_window.active

      update_equip_selection

    elsif @item_window.active

      update_item_selection

    end

  end

  def update_equip_selection

    @equip_window.update

    kyon_ekuip_points_scn_eqp_up_eqp_sel

  end

  def update_item_selection

    @item_window.update

    if Input.trigger?(Input::B)

      Sound.play_cancel

      @equip_window.active = true

      @item_window.active = false

      @item_window.index = -1

      return

    elsif Input.trigger?(Input::C)

      item = @item_window.item

      pos = @equip_window.index

      if item and !@actor.enough_ep?(pos, item)

        Sound.play_buzzer

        return

      end

      Sound.play_equip

      @actor.change_equip(pos, item)

      @equip_window.active = true

      @item_window.active = false

      @item_window.index = -1

      @item_window.refresh

      @equip_window.refresh

    end

  end

end

class Scene_Battle

  alias :kyon_ekuip_points_scn_btl_up :update

  alias :kyon_ekuip_points_scn_btl_up_act_cmdsel :update_actor_command_selection

  def create_equipment_windows

    actor = @active_battler

    if actor.block_equip_change

      Sound.play_buzzer

      return

    end

    Sound.play_decision

    wx, wy = EkuipPoints::BATTLE_EQUIP_WIN_XY

    ww = Graphics.width

    wh = Graphics.height - @actor_command_window.height

    @ep_window = EkuipPoints::ActorStatsWindow.new(actor)

    @equip_window = Window_EquipMod.new(wx, wy, actor)

    @equip_item_window = Window_EquipItem.new(0, 0, ww, wh, actor, 0)

    @equip_windows = [@ep_window, @equip_window, @equip_item_window]

    @actor_command_window.active = false

    @equip_index = 0

    @equip_item = true

  end

  def dispose_equipment_windows

    Sound.play_cancel

    @equip_windows.each {|window| window.dispose }

    @actor_command_window.active = true

    @equip_item = false

  end

  def update

    if @equip_item

      update_equipment

    else

      kyon_ekuip_points_scn_btl_up

    end

  end

  def update_equipment

    update_basic(true)

    update_info_viewport

    case @equip_index

    when 0

      update_equip_type

    when 1

      update_equip_list

    end

  end

  def refresh_equip_type

    type = @equip_window.index

    @equip_item_window.equip_type = type

    @equip_item_window.index = -1

  end

  def update_equip_type

    @equip_window.update

    if Input.trigger?(Input::B)

      dispose_equipment_windows

      return

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      @equip_item_window.active = true

      @equip_window.active = false

      @equip_item_window.reset_index

      return @equip_index = 1

    elsif Input.trigger?(Input::DOWN)

      refresh_equip_type

      return

    elsif Input.trigger?(Input::UP)

      refresh_equip_type

    end

  end

  def back_to_main_equip

    @equip_item_window.index = -1

    @equip_item_window.active = false

    @equip_window.active = true

    @equip_index = 0

  end

  def update_equip_list

    @equip_item_window.update

    if Input.trigger?(Input::B)

      Sound.play_cancel

      back_to_main_equip

      return

    elsif Input.trigger?(Input::C)

      pos = @equip_window.index

      item = @equip_item_window.item

      if item and !@active_battler.enough_ep?(pos, item)

        Sound.play_buzzer

        return

      end

      Sound.play_equip

      @active_battler.change_equip(pos, item)

      @equip_item_window.refresh

      @equip_window.refresh

      @ep_window.refresh

      back_to_main_equip

    end

  end

  def update_actor_command_selection

    if Input.trigger?(Input::X)

      create_equipment_windows

      return

    end

    kyon_ekuip_points_scn_btl_up_act_cmdsel

  end

end

DOWNLOAD DEMO

Terms & Conditions

Free as in beer for non-commercial use.
Include me in your game credits!
That's it!

Scene_File FIX

Sat, 11 Oct 2025 22:30:34 +0000

Scene_File FIX

for VX ACE

by Kyonides

Introduction

Scripts like GOBJ try to catch weird stuff the RM engine does when creating visual objects or disposing of them, but I think it's a terrible approach because they simply ignore the bugs already contained in the default scripts.

Yes, I know that VX ACE includes 2 bug fixes by default nowadays. Still, they're not all inclusive at all. There's one potential issue that has been ignored for quite a long time: the disposal of a Viewport object BEFORE its children have been disposed. Those children objects include Sprites and Windows. A perfect example of this is the Scene_File class, the parent class of Scene_Save and Scene_Load.

In the default script you can find the terminate method that says:

Code:
  def terminate

    super

    @savefile_viewport.dispose

    @savefile_windows.each {|window| window.dispose }

  end

That means that the Scene_File class and its children classes are disposing of the Viewport right before it takes care of the Savefile windows. A bad choice indeed. It should always followed the opposite order.

Get rid of:

The children objects first
Then dispose of the parent object safely.

How can you fix it?

Well, the solution is QUITE SIMPLE: just invert the order in which those objects get disposed of, and that's it. So you'd only need to paste the following code in the bug fix section of the Script Editor and you'll be fine:

Code:
# * Scene_File FIX * #

class Scene_File

  def terminate

    super

    @savefile_windows.each {|window| window.dispose }

    @savefile_viewport.dispose

  end

end

Why is this fix relatively important for you as a game developer?

It might not look impressive or critical at all, yet, it's highly convenient to prevent the engine from trying to do stuff in the incorrect / not-so-logical order in the first place. Debugger scripts like GOBJ will try to catch all those windows or their custom contents as critical objects that need to be notified otherwise.

Terms & Conditions

None.

KInfoMenu VX

Wed, 17 Sep 2025 02:20:26 +0000

KInfoMenu VX

by Kyonides

Introduction

The script allows you to create some sort of tutorial menu with lots of options using a GUI similar to my other script FancyChoices VX.
As the game developer you can define what texts and pictures you will display on screen. You can also play SE if deemed necessary.

Nope, this is NOT a Plug & Play script at all, guys!

If you want to customize it, you will have to edit several CONSTANTS in the KInfoMenu module first.

All texts will be shown on top of the option boxes or on a typical message window. This also means that your typical note tags like \n[1] or \c[2] will work normally.

The pictures will be shown on the center of the screen right when its corresponding text message gets displayed there.

Understanding the Options Feature

There are 3 different levels of options, namely the Main Choices plus the first and second subcategories. Those subcategories depend on Hashes to let you customize its contents.

Option labels are simple to understand, they are just a list of texts:

Code:
SUB_CAT1["Combat"]  = ["Allies", "Enemies", "FF Menu", "Section 4", "Section 5", "Section 6", "Section 7"]

"Combat" is a key that can be found in the Main Choices list:

Code:
MAIN_CHOICES    = ["Combat", "Controls", "Concepts"]

So both subcategories should use keys that already exist on the previous subcategory or the main choices list.

The text hashes sport 3 keys and their respective values. Those keys are :text, :se and :pic and that's it.

You can leave the :pic and :se hashes empty if you need to, but you can add custom pictures or SFX at any given time. Just follow this example:

Code:
SUB_CAT1_TEXTS["Enemies"] = {

  :se => { 1 => "Battle1", 2 => "Battle2" },

  :pic => { 1 => "093-Monster07", 2 => "099-Monster13" },  

  :text => [

    "You're not given a chance to think twice.",

    "All mobs definitely hate you.",

    "They'll sweep the floor with your death body",

    "while laughing maniacally.",

    "Please don't challenge them unless you know",

    "very well what you're doing.",

    "You've been warned!",

  ] }

So you need to pick a CONSTANT, then call its option key, and make it contain a { Hash }.
The :se and :pic keys use page indexes as their hash keys, but you can skip pages at will.
The :text hash has a very interesting feature that you should know about from the very beginning. If you plan to display less than 4 lines of text on a given page, and you expect another page to show up next after pressing the OK button, you will have to add empty Strings "" and a comma , per empty line. And this is mandatory.

A Friendly Reminder

If a key like "Section 4" does not exist either in SUB_CAT1_TEXTS or SUB_CAT2_TEXTS, the script will skip the whole enchilada to prevent it from crashing.

NOTES

The comments include an explanation that claims that calling the custom scene is optional. Well, that is only true if you pretend to customize your main menu to include an option to open the KInfoMenu scene. If you are planning to use any NPC as an interface for this tutorial menu, you will have to make that script call at all costs.

The WINDOW_BACK_OP constant will let you set the message window's back opacity.

I don't care if there are other ways to achieve the same goal. I just wanted to create this special menu, and that's it!

Screenshots

Several Snapshots

The Script

Code:
# * KInfoMenu VX * #

#   Scripter : Kyonides Arkanthes

#   v1.2.3 - 2025-09-17

#   Not a Plug & Play Script!

# This scriptlet lets you setup a simple tutorial menu.

# NOTES on Message Window's Contents:

# For the message window, empty lines are equally as important as normal ones.

# They are used as fillers, and this matters a lot whenever you're trying to

# display multiple pages on screen. If you ever skip them, you'll soon notice

# that certain lines of text do appear sooner than expected.

# * Optional Script Call * #

# $scene = KInfoMenu::Scene.new

module KInfoMenu

  BACKDROP         = "Title"

  TITLE_FILENAME   = "title480"

# BGM Options: "" for no song, "Some Name" for any specific BGM

  TUTORIAL_BGM     = "Ship"

  TEXT_ALIGN_X     = :center

  CHOICE_ALIGN_X   = :center

  CHOICE_TOP_Y     = 76

  CHOICE_MARGIN_Y  = 16

  CHOICE_ROW_MAX   = 6

  MAIN_CHOICE_FILE = "box280"

  SUB_CHOICE_FILE  = "box240"

  CHOICE_CURSOR    = "cursor_shield"

  MAIN_TITLE       = "Tutorial Menu"

  MAIN_CHOICES     = ["Combat", "Controls", "Concepts"]

  FACE_FILENAME    = "Actor1"

  FACE_INDEX       = 0

  WINDOW_BACKDROP  = 0 # 0, 1 or 2 only!

  WINDOW_POSITION  = 2 # 0, 1 or 2 only!

  WINDOW_BACK_OP   = 255

  WINDOW_CONFIG = [FACE_FILENAME, FACE_INDEX, WINDOW_BACKDROP, WINDOW_POSITION]

# - Message Window's Contents - #

  INTRO_TEXTS = ["Welcome to the Great Hero's Tutorial!",

                 "I'm your valorous host \c[2]\n[1]\c[0].",

                 "Nice to meet you!\i[12]"]

# - The Don't Touch These Lines Section - #

  MAIN_CHO_COLS  = 1

  SUB_CAT1       = {}

  SUB_CAT2       = {}

  SUB_CAT1_TEXTS = {}

  SUB_CAT2_TEXTS = {}

  SUB_CAT1.default       = []

  SUB_CAT2.default       = []

  SUB_CAT1_TEXTS.default = {}

  SUB_CAT2_TEXTS.default = {}

# - End of Section - #

  SUB_CAT1["Combat"]   = ["Allies", "Enemies", "FF Menu", "Section 4",

                          "Section 5", "Section 6", "Section 7"]

  SUB_CAT1["Controls"] = ["Decision", "Cancel"]

  SUB_CAT1["Concepts"] = ["Concepts 1", "Concepts 2", "Concepts 3"]

  SUB_CAT1_TEXTS["Allies"] = {

  :se => {},

  :pic => {},

  :text => [

    "Most of the time your allies will be very useless.",

    "Just keep them alive to avoid making very large",

    "donations to your local priest to heal those",

    "reckless companions after every single battle."

  ] }

  SUB_CAT1_TEXTS["Enemies"] = {

  :se => { 1 => "Battle1", 2 => "Battle2" },

  :pic => { 1 => "Mimic", 2 => "Assassin" },

  :text => [

    "You're not given a chance to think twice.",

    "All mobs definitely hate you.",

    "They'll sweep the floor with your death body",

    "while laughing maniacally.",

    "Please don't challenge them unless you know",

    "very well what you're doing.\|",

    "You've been warned!",

    ""

  ] }

  SUB_CAT1_TEXTS["FF Menu"] = {

  :se => {},

  :pic => { 1 => "FF9_MenuBar old" },

  :text => [

    "This tutorial uses an old fashioned FF9 menubar.",

    "We don't know when it will be replaced by a",

    "new one. The game developer has refused to",

    "address the issue on social media."

  ] }

  SUB_CAT2["Concepts 1"] = ["Concept 1", "Concept 2", "Concept 3"]

  SUB_CAT2_TEXTS["Concept 1"] = {

  :se => {},

  :pic => {},

  :text => [

    "You've chosen the Proof of Concept #1!\|",

    "Hurray..."

  ] }

class TextBox

  def initialize(pos, total, vp=nil)

    @index = pos

    @max = total

    @row_max = CHOICE_ROW_MAX

    @col_max = (@max / @row_max) + 1

    @viewport = vp

    @backdrop = Sprite.new(vp)

    @label = Sprite.new(vp)

    @label.z = 50

  end

  def set_image(filename)

    @filename = filename

    set_bitmap

    set_text_bitmap

    reset_alignment

  end

  def set_bitmap

    bitmap = Cache.picture(@filename)

    @width = bitmap.width

    @height = bitmap.height

    @rect = bitmap.rect

    @col_width = Graphics.width

    @center_x = (@col_width - @width) / 2

    @backdrop.bitmap = bitmap

  end

  def set_align_x

    case TEXT_ALIGN_X

    when :left

      0

    when :center

      1

    when :right

      2

    else

      TEXT_ALIGN_X

    end

  end

  def set_text_bitmap

    @align_x = set_align_x

    @label.bitmap = Bitmap.new(@width, @height)

  end

  def set_title_xy

    @backdrop.x = @center_x

    @backdrop.y = 8

  end

  def set_align_xy

    h = @height + CHOICE_MARGIN_Y

    if @max < @row_max

      @backdrop.x = @center_x

      @backdrop.y = CHOICE_TOP_Y + @index * h

    else

      n = @index % @col_max

      cw = @col_width / 2

      @backdrop.x = n * cw + (cw - @width) / 2

      @backdrop.y = CHOICE_TOP_Y + @index / @col_max * h

    end

  end

  def reset_alignment

    @index ? set_align_xy : set_title_xy

    @label.x = @backdrop.x

    @label.y = @backdrop.y

  end

  def x

    @backdrop.x

  end

  def y

    @backdrop.y

  end

  def set_text(text)

    @text = text

    bit = @label.bitmap

    bit.clear

    bit.draw_text(@rect, text, @align_x)

  end

  def dispose

    @label.bitmap.dispose

    @label.dispose

    @backdrop.bitmap.dispose

    @backdrop.dispose

  end

  attr_reader :height, :text

end

class MessageWindow < Window_Message

  def initialize

    super

    self.opacity = @background == 0 ? 255 : 0

    self.back_opacity = WINDOW_BACK_OP

  end

  def reset_window

    @background = $game_message.background

    @position = $game_message.position

    self.opacity = @background == 0 ? 255 : 0

    self.back_opacity = WINDOW_BACK_OP

    case @position

    when 0  # Top

      self.y = 0

      @gold_window.y = 360

    when 1  # Middle

      self.y = 144

      @gold_window.y = 0

    when 2  # Bottom

      self.y = 288

      @gold_window.y = 0

    end

  end

  def new_page?

    @text and !@text.empty? and @line_count >= MAX_LINE

  end

  def input_pause

    if Input.trigger?(Input::B) or Input.trigger?(Input::C)

      $game_message.new_page = new_page?

    end

    super

  end

  def open_message

    start_message

    open

    self.visible = true

  end

  def clear_contents

    self.pause = false

    self.index = -1

    @gold_window.close

    @number_input_window.active = false

    @number_input_window.visible = false

  end

end

class Spriteset

  def initialize

    create_variables

    create_backdrop

    create_viewports

    create_title

    create_picture

    create_main_choices

    create_cursors

    update_box(0)

    @sprites = @cursors + [@backdrop, @picture]

  end

  def create_variables

    @index = 0

    @section_index = 0

    @subsection_index = 0

    @sound = RPG::SE.new

    @cursors = []

    @sections = []

    @subsections = []

    @main_boxes = []

    @section_boxes = []

    @subsection_boxes = []

    @section_viewports = []

    @subsection_viewports = []

  end

  def create_backdrop

    @backdrop = Sprite.new

    @backdrop.bitmap = Cache.system(BACKDROP)

  end

  def create_viewports

    @viewport_rect = [0, 0, Graphics.width, Graphics.height]

    @main_viewport = Viewport.new(*@viewport_rect)

    @picture_viewport = Viewport.new(*@viewport_rect)

    @picture_viewport.z = 1000

  end

  def create_title

    @title = TextBox.new(nil, 0, nil)

    @title.set_image(TITLE_FILENAME)

    @title.set_text(MAIN_TITLE)

  end

  def create_picture

    @picture = Sprite.new(@picture_viewport)

    @picture.y = 48

    @picture.visible = false

    @picture.bitmap = Bitmap.new(Graphics.width, Graphics.height - 96)

  end

  def create_main_choices

    filename = MAIN_CHOICE_FILE

    total = MAIN_CHOICES.size

    MAIN_CHOICES.each_with_index do |choice, n|

      box = TextBox.new(n, total, @main_viewport)

      box.set_image(filename)

      box.set_text(choice)

      @main_boxes << box

    end

    @item_max = @main_boxes.size

  end

  def create_cursors

    box = @main_boxes[@index]

    @main_cursor = Sprite.new(@main_viewport)

    @main_cursor.z = 100

    @main_cursor.bitmap = Cache.system(CHOICE_CURSOR)

    @main_cursor.x = box.x + 4

    @offset_y = (box.height - @main_cursor.bitmap.height) / 2

    @main_cursor.y = box.y + @offset_y

    @section_cursor = Sprite.new

    @section_cursor.visible = false

    @section_cursor.z = 100

    @section_cursor.bitmap = Cache.system(CHOICE_CURSOR)

    @subsection_cursor = Sprite.new

    @subsection_cursor.visible = false

    @subsection_cursor.z = 100

    @subsection_cursor.bitmap = Cache.system(CHOICE_CURSOR)

    @cursors << @main_cursor << @section_cursor << @subsection_cursor

  end

  def update_main

    if Input.trigger?(Input::UP)

      Sound.play_cursor

      update_box(-1)

      return

    elsif Input.trigger?(Input::DOWN)

      Sound.play_cursor

      update_box(1)

    end

  end

  def update_box(n)

    @index = (@index + n) % @item_max

    box = @main_boxes[@index]

    @section_title = box.text

    @main_cursor.x = box.x + 4

    @main_cursor.y = box.y + @offset_y

  end

  def show_main

    @title.set_text(MAIN_TITLE)

    @main_viewport.visible = true

  end

  def hide_main

    @main_viewport.visible = false

  end

  def find_section_viewport

    @section_viewports[@index] ||= Viewport.new(*@viewport_rect)

  end

  def find_subsections

    @sections[@index] ||= SUB_CAT1[@section_title].dup

  end

  def find_section_boxes

    @section_boxes[@index] ||= []

  end

  def setup_section

    @section_viewport = find_section_viewport

    @section_list = find_subsections

    @current_boxes = find_section_boxes

    create_section if @current_boxes.empty?

    reset_section

    update_section_box(0)

    @title.set_text(@section_title)

    @section_viewport.visible = true

  end

  def create_section

    return if @section_list.empty?

    filename = SUB_CHOICE_FILE

    total = @section_list.size

    @section_list.each_with_index do |choice, n|

      box = TextBox.new(n, total, @section_viewport)

      box.set_image(filename)

      box.set_text(choice)

      @current_boxes << box

    end

  end

  def reset_section

    @section_max = @current_boxes.size

    @col_max = (@section_max / CHOICE_ROW_MAX) + 1

    @section_index = 0

    box = @current_boxes[@section_index]

    @section_oy1 = (box.height - @section_cursor.bitmap.height) / 2

    @section_cursor.visible = box ? true : false

  end

  def show_section

    @title.set_text(@section_title)

    @section_viewport.visible = true

    @section_cursor.visible = true

  end

  def hide_section(clear)

    @section_cursor.visible = false

    @section_viewport.visible = false

    return unless clear

    @section_viewport = @current_boxes = nil

    @section_index = 0

  end

  def update_section

    if Input.trigger?(Input::UP)

      Sound.play_cursor

      update_section_box(-@col_max)

      return

    elsif Input.trigger?(Input::DOWN)

      Sound.play_cursor

      update_section_box(@col_max)

      return

    end

    return if @col_max == 1

    if Input.trigger?(Input::LEFT)

      Sound.play_cursor

      update_section_box(-1)

      return

    elsif Input.trigger?(Input::RIGHT)

      Sound.play_cursor

      update_section_box(1)

    end

  end

  def update_section_box(n)

    @section_index = (@section_index + n) % @section_max

    box = @current_boxes[@section_index]

    @subsection_title1 = box.text

    @section_cursor.x = box.x + 4

    @section_cursor.y = box.y + @section_oy1

  end

  def set_pictures(pictures)

    @page_index = 1

    @pictures = pictures

    show_picture

  end

  def show_picture

    picture = @pictures[@page_index]

    return unless picture

    @picture.bitmap.dispose

    @picture.bitmap = bit = Cache.picture(picture)

    @picture.x = (Graphics.width - bit.width) / 2

    @picture.y = (Graphics.height - bit.height - 128) / 2

    @picture.visible = true

  end

  def set_sfx(sfx)

    @sfx = sfx

    play_sound

  end

  def play_sound

    @sound.name = @sfx[@page_index] || ""

    @sound.play

  end

  def find_subsection_viewport

    @subsection_viewports[@section_index] ||= Viewport.new(*@viewport_rect)

  end

  def find_subsections_lvl2

    @subsections[@section_index] ||= SUB_CAT2[@subsection_title1].dup

  end

  def find_subsection_boxes

    @subsection_boxes[@section_index] ||= []

  end

  def setup_subsection

    @subsection_viewport = find_subsection_viewport

    @subsection_list = find_subsections_lvl2

    @current_subboxes = find_subsection_boxes

    create_subsection if @current_subboxes.empty?

    reset_subsection

    update_subsection_box(0)

    box = @current_subboxes[@subsection_index]

    @subsection_title2 = box ? box.text : ""

    @title.set_text(@subsection_title1)

    @subsection_viewport.visible = true

  end

  def create_subsection

    return if @subsection_list.empty?

    filename = SUB_CHOICE_FILE

    total = @subsection_list.size

    @subsection_list.each_with_index do |choice, n|

      box = TextBox.new(n, total, @subsection_viewport)

      box.set_image(filename)

      box.set_text(choice)

      @current_subboxes << box

    end

  end

  def reset_subsection

    @subsection_max = @current_subboxes.size

    @subcol_max = (@subsection_max / CHOICE_ROW_MAX) + 1

    @subsection_index = 0

    box = @current_subboxes[@subsection_index]

    @section_oy2 = (box.height - @subsection_cursor.bitmap.height) / 2

    @subsection_cursor.visible = box ? true : false

  end

  def hide_subsection

    @subsection_cursor.visible = false

    @subsection_viewport.visible = false

    @subsection_viewport = @current_subboxes = nil

    @subsection_index = 0

  end

  def update_subsection

    if Input.trigger?(Input::UP)

      Sound.play_cursor

      update_subsection_box(-@subcol_max)

      return

    elsif Input.trigger?(Input::DOWN)

      Sound.play_cursor

      update_subsection_box(@subcol_max)

      return

    end

    return if @subcol_max == 1

    if Input.trigger?(Input::LEFT)

      Sound.play_cursor

      update_subsection_box(-1)

      return

    elsif Input.trigger?(Input::RIGHT)

      Sound.play_cursor

      update_subsection_box(1)

    end

  end

  def update_subsection_box(n)

    @subsection_index = (@subsection_index + n) % @subsection_max

    box = @current_subboxes[@subsection_index]

    @subsection_title2 = box.text

    @subsection_cursor.x = box.x + 4

    @subsection_cursor.y = box.y + @section_oy2

  end

  def hide_picture

    @picture.bitmap.dispose

    @picture.bitmap = Bitmap.new(Graphics.width, Graphics.height - 96)

    @picture.visible = false

  end

  def update_extras

    return unless $game_message.new_page

    $game_message.new_page = nil

    @page_index += 1

    show_picture

    play_sound

  end

  def dispose

    @sprites.each do |sprite|

      sprite.bitmap.dispose

      sprite.dispose

    end

    @subsection_boxes.each do |boxes|

      next unless boxes

      boxes.each {|box| box.dispose }

    end

    @section_boxes.each do |boxes|

      next unless boxes

      boxes.each {|box| box.dispose }

    end

    @main_boxes.each {|box| box.dispose }

    @title.dispose

    @section_viewports.each {|vp| vp.dispose if vp }

    @picture_viewport.dispose

    @main_viewport.dispose

    @section_boxes.clear

    @main_boxes.clear

    @section_viewports.clear

  end

  attr_reader :subsection_title1, :subsection_title2

end

class Scene

  def initialize(index=nil)

    @main_menu_index = index

    @map_bgm = RPG::BGM.last

    @bgm = RPG::BGM.new

    return if TUTORIAL_BGM.empty?

    @bgm.name = TUTORIAL_BGM

    @bgm.play

  end

  def main

    start

    Graphics.transition

    update_basic while @stage

    Graphics.freeze

    terminate

  end

  def start

    @stage = :message

    @next_stage = :main

    @spriteset = Spriteset.new

    @message_window = MessageWindow.new

    $game_message.setup_message(*WINDOW_CONFIG)

    $game_message.set_tutorial_texts(INTRO_TEXTS)

  end

  def update_basic

    Graphics.update

    Input.update

    update

  end

  def close_message

    $game_message.texts.clear

    @message_window.clear_contents

    @message_window.visible = false

    @spriteset.hide_picture

    @stage = @next_stage

  end

  def update

    case @stage

    when :message

      update_message

    when :main

      update_main

    when :section

      update_section

    when :subsection

      update_subsection

    end

  end

  def update_message

    @message_window.update

    while $game_message.visible

      Graphics.update

      Input.update

      @message_window.update

      @spriteset.update_extras

    end

    close_message

  end

  def update_main

    @spriteset.update_main

    if Input.trigger?(Input::B)

      Sound.play_cancel

      if @main_menu_index

        $scene = Scene_Menu.new(@main_menu_index)

      else

        $scene = Scene_Map.new

      end

      return @stage = nil

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      @spriteset.hide_main

      @spriteset.setup_section

      @stage = :section

    end

  end

  def update_section

    @spriteset.update_section

    if Input.trigger?(Input::B)

      Sound.play_cancel

      @spriteset.hide_section(true)

      @spriteset.show_main

      return @stage = :main

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      key = @spriteset.subsection_title1

      if SUB_CAT2[key].any?

        show_subsection

      else

        show_section_message(key)

      end

    end

  end

  def show_subsection

    @spriteset.hide_section(nil)

    @spriteset.setup_subsection

    @stage = :subsection

  end

  def show_section_message(key)

    data = SUB_CAT1_TEXTS[key].dup

    return if data.empty?

    pictures = data[:pic]

    message = data[:text]

    sfx = data[:se]

    $game_message.setup_message(*WINDOW_CONFIG)

    $game_message.set_tutorial_texts(message)

    @message_window.open_message

    @spriteset.set_pictures(pictures)

    @spriteset.set_sfx(sfx)

    @next_stage = :section

    @stage = :message

  end

  def update_subsection

    @spriteset.update_subsection

    if Input.trigger?(Input::B)

      Sound.play_cancel

      @spriteset.hide_subsection

      @spriteset.show_section

      return @stage = :section

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      key = @spriteset.subsection_title2

      data = SUB_CAT2_TEXTS[key]

      return if data.empty?

      message = data[:text]

      pictures = data[:pic]

      sfx = data[:se]

      $game_message.setup_message(*WINDOW_CONFIG)

      $game_message.set_tutorial_texts(message)

      @message_window.open_message

      @spriteset.set_pictures(pictures)

      @spriteset.set_sfx(sfx)

      @next_stage = :subsection

      @stage = :message

    end

  end

  def terminate

    @message_window.dispose

    @spriteset.dispose

    $game_message.custom_scene = nil

    $game_message.clear

    return if TUTORIAL_BGM.empty?

    if $game_map.autoplay_bgm?

      $game_map.autoplay

    elsif @map_bgm

      @map_bgm.play

    end

  end

end

end

class Game_Message

  def setup_message(*options)

    options = options.dup

    @face_name = options.shift

    @face_index = options.shift

    @background = options.shift

    @position = options.shift

    @custom_scene = true

  end

  def set_tutorial_texts(original_texts)

    @texts = original_texts.dup

    @texts.each do |line|

      line.gsub!("\e", "\\c[")

      line.gsub!(/(.)\^/) { "#{$1}\\^" }

      line.gsub!(/([^\\])\|/) { "#{$1}\\|" }

      line.gsub!(/(\-|,|;|:|!)\./) { "#{$1}\\." }

      line.gsub!(/[\b]/i, "\\b")

      line.gsub!(/([^\\])i\[([0-9]+)\]/i) { "#{$1}\\i[#{$2}]" }

      line.gsub!(/\n\[([0-9]+)\]/i) { "\\n[#{$1}]" }

    end

    @visible = true

  end

  attr_accessor :new_page, :custom_scene

end

class Game_Map

  def autoplay_bgm?

    @map.autoplay_bgm

  end

end

Terms & Conditions

Free as in beer for non-commercial games.
Include my nickname in your game credits.
That's it!

FPLE ACE Addon/Enhancement.

Thu, 11 Sep 2025 16:42:22 +0000

@A.I. Topical Post. Tag.

I upgraded FPLE Ace Using Claude.AI, Integrated a 4-Side & 6-Side box comment, which can create buildings/grass boxes/objects.
6 Side had type2+d1 & type1+d1)) but changed it to a type 0 to save FPS, you can add it back if you want.

For below/Above, type 0 objects you want to walk over add, 1-Side, to them.
I added code the following code so these player facing objects without 1-Side push forward, for NPCs.
if dy == 0 && dx == 0 && surface.character.fple_type == 0 && surface.character.fple_one_side == false.

(Fit,Type1,D1,1Side,V2) objects have a side profile added to them, but should always be, same not below/above.
you can jump over these with a moveset thuf-on/step forward step forward thur-off, they are a type of ledge.

You may have to code in your own. (Fit,Type2,D1,1Side,V2), I'm not currently tested to check its same function.

I've worked out a fix for rotation letting you see events thur walls briefly, here is the 1st rough draft of the script.
I would have posted a few days sooner, but was having issues with strafing crashing the game for some reason.

The resolution is also no longer Default, it's 608x417, you can place it back with the original script, or pick Res 2.

The Enhanced Script requires Background Addon to function properly, I've not worked out the private call issue.

Code:
#========================Author: MGC=============================

# First Person Labyrinth Explorer (FPLE) Engine - VX Ace version.

# v.1.5 old, now upgraded to v.1.8 using Claude.AI by 5Brainplay.

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

# This script allows the map to be displayed in first-person view,

# while maintaining tile-by-tile movement, similar to the

# Etrian Odyssey series (Nintendo DS/3DS). # THIS IS NOT A SCRIPT FOR MAKING AN FPS, BUT AN FPRPG.

#

# This is a port of version 1.5 of the FPLE for RPG Maker XP, with

# a few small additions.

#

# Features:

# - Can only be enabled on certain maps in the project

# - Forward/backward movement, left/right movement

# and 90° rotation

# - Ability to lower quality while moving to reduce lag

# - Translucency and blend type support

# for events

#

# Limitations:

# - Not really suitable for moving events from one tile to another.

# This should work, but use sparingly. # - Animations are displayed above everything

# - The player cannot jump or move diagonally

# - The resolution must be the default, i.e., 544px x 416px

# - No transparency for walls

# - No different heights: a single level for the floor and ceiling

#

# Instructions:

# This script must be placed below the original scripts but above "Main"

# It requires the MGC_FPLE_Ace_1_1.dll file

#

# - Map Creation

# Maps must be exported into the project from the dedicated editor,

# present in the Marta project starting with version 1.0.0

#

# - Events

# Events with a graphical representation are displayed

# vertically (like walls), centered, and always facing the

# player. The "Comment..." command allows you to control this display:

# "Type 0": Always faces the player (default)

# "Type 1": Horizontally oriented in the RM editor view (top view)

# "Type 2": Vertically oriented in the RM editor view (top view)

# "Stretch": The image is stretched to the dimensions of a wall (square)

# "Fit": The image is stretched to fit within the dimensions of a wall, the

# aspect ratio is maintained. Automatically applied if

# the dimensions exceed those of a wall (new in VX Ace)

# "Zoom X.X": zoom the image (new in VX Ace), for example, to double

# the dimensions, write: "Zoom 2.0"

# "V-Align 0": vertical alignment at the top (at ceiling level)

# "V-Align 1": vertical alignment in the center (default)

# "V-Align 2": vertical alignment at the bottom (at floor level)

# "D-Align 0": depth alignment in front/left, for types 1 and 2

# "D-Align 1": depth alignment in the center, for types 1 and 2 (default)

# "D-Align 2": depth alignment in the back/right, for types 1 and 2

# "1-Side": texture applied to one side only => appears mirrored behind

# "2-Side": texture applied to two side only => appears mirrored behind #Extra Unused Call To Code#

# "4-Side": texture applied to four sides to create the illusion of box

# "6-Side":  texture applied to four sides to create the illusion of grass.

# - Technical Parameters

# In the CONFIGURATION section at the beginning of the script, you will find the

# following constants whose values can be modified:

# - VIEW_DISTANCE: "Surfaces" (textured square polygons of fixed

# dimensions representing tiles and events) are only

# displayed within a certain distance around

# the player. This constant represents this distance,

# expressed in tiles (default value: 6). The higher

# this value, the greater the risk of lag.

# - RESOLUTION: Drawing the entire screen every frame requires

# a lot of resources. During movement, it is

# possible to use a lower screen resolution and the

# Render will then be zoomed to fit 544px x 416px.

# 0: Maximum resolution (544px*416px) Changed to (840px*560px)

# 1: Medium resolution (408px*312px)  Changed to (608px*417px)

# 2: Low resolution (272px*208px) Changed to (544px*417px)

# 3: Minimum resolution (204px*156px) Changed to (408px*278px)

# 4: Test resolution (204px*156px) Changed to (332px*222px)

# - ALWAYS_SAME_RES: If true, the same resolution will be used when stationary

# as when moving (see RESOLUTION)

# If false, the maximum resolution will be used when stationary

# (default value)

# - LIGHT_DISTANCE: To prevent surfaces from suddenly appearing on the screen,

# this constant represents the distance in tiles beyond

# which the opacity of the surfaces will be zero.

# The opacity change is gradual. If there is

# no parallax, the screen background is black and the

# surfaces will become increasingly darker with distance.

# A value of 0 disables this feature.

#

# - Commands that can be used in scripts (possible via the "Script..."

# command of an event):

# - $game_temp.set_view(new_view_distance)

# - $game_temp.set_light(new_light_distance)

# - $game_temp.increase_light

# - $game_temp.decrease_light

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

module FPLE

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

  # * CONFIGURATION

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

  VIEW_DISTANCE = 22 # in tiles, > 0

  LIGHT_DISTANCE = 11 # in tiles, >=0, 0=deactivated

  RESOLUTION = 1 # quality when moving, 0=max, 1=medium, 2=low, 3=ugly

  ALWAYS_SAME_RES = true # if true, quality at stand = quality when moving

                          # if false, quality at stand = quality max

  SKIP_DISTANT_CHARS = true  # Skip character updates beyond view distance

  BATCH_SURFACE_UPDATES = true  # Update surfaces in batches

  AGGRESSIVE_CULLING = true     # More aggressive visibility culling

end

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

# ** FPLE Core

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

module FPLE

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

  # * Constantes

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

  MAP_SIDES = [4, 3, 5, 2]

  MAP_SIDES_LEFT = [5, 4, 2, 3]

  MAP_SIDES_RIGHT = [3, 2, 4, 5]

  PLAYER_MOVE_FORWARD = [[0, 1], [-1, 0], [1, 0], [0, -1]]

  PLAYER_MOVE_SPEED = [0, 1, 2, 4, 6, 8, 12]

  TURN_LEFT = [6, 2, 8, 4]

  COS_TABLE = [4096, 4095, 4094, 4090, 4086,

  4080, 4074, 4065, 4056, 4046, 4034, 4021, 4006, 3991, 3974,

  3956, 3937, 3917, 3896, 3873, 3849, 3824, 3798, 3770, 3742,

  3712, 3681, 3650, 3617, 3582, 3547, 3511, 3474, 3435, 3396,

  3355, 3314, 3271, 3228, 3183, 3138, 3091, 3044, 2996, 2946,

  2896, 2845, 2793, 2741, 2687, 2633, 2578, 2522, 2465, 2408,

  2349, 2290, 2231, 2171, 2110, 2048, 1986, 1923, 1860, 1796,

  1731, 1666, 1600, 1534, 1468, 1401, 1334, 1266, 1198, 1129,

  1060, 991, 921, 852, 782, 711, 641, 570, 499, 428,

  357, 286, 214, 143, 71, 0]

  RENDER = Win32API.new("MGC_FPLE_Ace_1_2", "RenderFPLE", "lll", "l") # [1.5]

  RENDER_ROT = Win32API.new("MGC_FPLE_Ace_1_2", "RenderFPLErot", "lll", "l") # [1.5]

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

  # * Retourne l'angle d'orientation

  # return Integer

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

  def self.angle

    return @angle

  end

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

  # * Retourne le décalage horizontal

  # return Integer

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

  def self.offset_x

    return @offset_x

  end

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

  # * Retourne le décalage en profondeur

  # return Integer

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

  def self.offset_y

    return @offset_y

  end

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

  # * Initialisation

  # param spriteset : FPLE::Spriteset_Map

  # param viewport : Viewport

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

  def self.initialize_fple(spriteset, viewport)

    @spriteset = spriteset

    @sprite_screen = Sprite.new(viewport)

    @sprite_move = Sprite.new(viewport)

    self.initialize_bitmaps

    @offset_x = 0

    @offset_y = 0

    @sprite_move.visible = false

    @lux_distance = $game_system.fple_light_distance << 5

    @angle = 0

    @trig = 0

    self.refresh_trig

    @count = 0

    $game_temp.force_render = true

    self.update

  end

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

  # * Création des objets Bitmap devant contenir le rendu 3D

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

  def self.initialize_bitmaps

    case $game_system.fple_resolution

    when 0

      width = 840

      height = 560

      coefficient_resolution = 0.75

    when 1

      width = 608

      height = 417

      coefficient_resolution = 1

    when 2

      width = 544

      height = 417

      coefficient_resolution = 1.133

    when 3

      width = 408

      height = 278

      coefficient_resolution = 1.5

    when 4

      width = 332

      height = 222

      coefficient_resolution = 2

    end

    if $game_system.fple_always_same_res

      @sprite_screen.bitmap = Bitmap.new(width, height)

      @sprite_screen.zoom_x = coefficient_resolution

      @sprite_screen.zoom_y = coefficient_resolution

    else

      @sprite_screen.bitmap = Bitmap.new(608, 417)

    end

    @sprite_move.bitmap = Bitmap.new(width, height)

    @sprite_move.zoom_x = coefficient_resolution

    @sprite_move.zoom_y = coefficient_resolution

  end

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

  # * Cherche les valeurs de sinus et cosinus en focntion de l'angle

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

  def self.refresh_trig

    @cos = FPLE::COS_TABLE[@angle]

    @sin = FPLE::COS_TABLE[91 - @angle]

  end

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

  # * Dispose

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

  def self.dispose

    @sprite_screen.dispose

    @sprite_move.dispose

  end

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

  # * Frame Update

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

# Modify the update method to use a more complete background fill

def self.update

  # Run garbage collection periodically during non-movement to reduce memory spikes.

  if !$game_temp.movement && Graphics.frame_count % 120 == 0

    GC.start

  end

  # Check if the player is actively moving or changing the view.

  if $game_temp.movement

    case $game_temp.movement_dir

    when 0 # fading distance + 1

      self.increase_fading_distance

    when 1 # fading distance - 1

      self.decrease_fading_distance

    when 3 # set fading distance

      self.set_fading_distance

    when 2 # Move backward

      self.move_backward

    when 4 # Strafe left

      self.strafe_left

    when 6 # Strafe right

      self.strafe_right

    when 8 # Move forward

      self.move_forward

    when 9 # Turn right

      self.turn_right

    when 10 # turn left

      self.turn_left

    end

    # Apply method 2 refactoring for sprite and rendering logic

    sprite_moving = $game_temp.movement

    active_sprite = sprite_moving ? @sprite_move : @sprite_screen

    inactive_sprite = sprite_moving ? @sprite_screen : @sprite_move

    active_sprite.visible = true

    inactive_sprite.visible = false

   if @angle != 0

      # Use lighter background color during rotation to prevent bleeding

      bg_color = Color.new(115, 190, 215, 255)  # Much lighter sky blue background

      active_sprite.bitmap.fill_rect(0, 0, active_sprite.bitmap.width,

                                     active_sprite.bitmap.height, bg_color)

    end

    # Clear the active sprite bitmap

    active_sprite.bitmap.clear unless $game_temp.movement_dir == 9 || $game_temp.movement_dir == 10 && $game_player.moving?

    # Determine if we should use rotation (only during movement and when angle != 0)

    use_rotation = sprite_moving && @angle != 0

    if use_rotation

      params = [@offset_y, @offset_x, @lux_distance, $game_player.direction, @trig, @cos, @sin, $game_map.fple_map.texturesets]

      FPLE::RENDER_ROT.call(active_sprite.bitmap.__id__, $game_map.surfaces.__id__, params.__id__)

    else

      params = [@offset_y, @offset_x, @lux_distance, $game_player.direction, $game_map.fple_map.texturesets]

      FPLE::RENDER.call(active_sprite.bitmap.__id__, $game_map.surfaces.__id__, params.__id__)

    end

    # Handle post-movement logic

    unless sprite_moving

      $game_player.update_nonmoving($game_temp.last_moving) if $game_temp.last_moving

    end

  # This block handles rendering when the player is not moving, but other

  # events or conditions (like character surfaces) need updating.

  elsif $game_player.moving? || $game_temp.force_render

    # Process updates for characters and events.

    $game_map.refresh_surfaces

    # Extract common character update logic to avoid duplication

    update_character = lambda do |event|

      # Only process if SKIP_DISTANT_CHARS is enabled

      return unless FPLE::SKIP_DISTANT_CHARS

      dist_x = ($game_player.real_x / 32) - (event.x)

      dist_y = ($game_player.real_y / 32) - (event.y)

      distance = Math.sqrt(dist_x**2 + dist_y**2)

      return if distance > FPLE::VIEW_DISTANCE

      event.update_fple_surface

    end

    # === START OF BATCH AND CULLING FIX ===

    # Updates characters in batches to avoid lag spikes, with optional distance skipping.

    if FPLE::BATCH_SURFACE_UPDATES

      $game_map.events.values.each_with_index do |event, i|

        # Only update a fraction of the events each frame.

        if @count % 5 == i % 5

          update_character.call(event)

        end

      end

    else

      # Fallback for no batching.

      $game_map.events.each_value(&update_character)

    end

    # === END OF BATCH AND CULLING FIX ===

    $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    @sprite_screen.bitmap.clear

    # Use consistent parameter structure

    params = [@offset_y, @offset_x, @lux_distance, $game_player.direction, $game_map.fple_map.texturesets]

    FPLE::RENDER.call(@sprite_screen.bitmap.__id__, $game_map.surfaces.__id__, params.__id__)

    $game_temp.force_render = false

    @count += 1

  end

end

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

  # * Frame Update - Augmentation de la distance d'éclairage

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

  def self.increase_fading_distance

    @count += 2

    @lux_distance += 2

    if @count == 32

      @count = 0

      $game_temp.movement = false

    end

  end

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

  # * Frame Update - Diminution de la distance d'éclairage

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

  def self.decrease_fading_distance

    if @lux_distance == 0

      @count = 0

      $game_temp.movement = false

    else

      @count += 2

      @lux_distance -= 2

      if @count == 32

        @count = 0

        $game_temp.movement = false

      end

    end

  end

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

  # * Frame Update - Définition d'une nouvelle distance d'éclairage

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

  def self.set_fading_distance

    @lux_distance = $game_system.fple_light_distance << 5

    $game_temp.movement = false

  end

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

  # * Frame Update - Déplacement en arrière

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

  def self.move_backward

    unless $game_temp.movement_init

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

      $game_temp.movement_init = true

      @offset_y = 128

    end

    @offset_y -= $game_player.move_speed_fple

    if @offset_y <= 0

      @offset_y = 0

      $game_temp.movement = false

      $game_temp.last_moving = true

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

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

  # * Frame Update - Déplacement latéral vers la gauche

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

  def self.strafe_left

    unless $game_temp.movement_init

      $game_map.refresh_surfaces

      $game_map.refresh_surfaces_strafe(0)

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

      $game_temp.movement_init = true

      @offset_x = 128

    end

    @offset_x -= $game_player.move_speed_fple

    if @offset_x <= 0

      @offset_x = 0

      $game_temp.movement = false

      $game_temp.last_moving = true

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

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

  # * Frame Update - Déplacement latéral vers la droite

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

  def self.strafe_right

    unless $game_temp.movement_init

      $game_map.refresh_surfaces_strafe(-1)

      $game_temp.movement_init = true

    end

    @offset_x += $game_player.move_speed_fple

    if @offset_x >= 128

      @offset_x = 0

      $game_temp.movement = false

      $game_temp.last_moving = true

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

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

  # * Frame Update - Déplacement en avant

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

  def self.move_forward

    @offset_y += $game_player.move_speed_fple

    if @offset_y >= 128

      @offset_y = 0

      $game_temp.movement = false

      $game_temp.last_moving = true

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

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

  # * Frame Update - Rotation vers la droite

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

  def self.turn_right

    unless $game_temp.movement_init

      $game_map.refresh_surfaces_turn_right(@spriteset.character_surfaces)

      $game_temp.movement_init = true

    end

    @angle += 5

    @trig = 1

    refresh_trig

    if @angle == 90

      @angle = 0

      $game_temp.movement = false

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

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

  # * Frame Update - Rotation vers la gauche

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

  def self.turn_left

    unless $game_temp.movement_init

      $game_map.refresh_surfaces_turn_left(@spriteset.character_surfaces)

      $game_temp.movement_init = true

      @angle = 90

    end

    @angle -= 5

    @trig = 0

    refresh_trig

    if @angle == 0

      $game_temp.movement = false

      $game_map.refresh_surfaces

      $game_map.refresh_character_surfaces(@spriteset.character_surfaces)

    end

  end

end

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

# ** DataManager

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

module DataManager

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

  # * Aliased methods (F12 compatibility)

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

  class << self

    unless @already_aliased_fple

      alias save_game_without_rescue_fple save_game_without_rescue

      @already_aliased_fple = true

    end

  end

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

  # * Execute Save (No Exception Processing)

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

  def self.save_game_without_rescue(index)

    if $game_map.fple_map # [1.2]

      textureset = $game_map.fple_map.textureset

      texturesets = $game_map.fple_map.texturesets

      $game_map.fple_map.textureset = nil

      $game_map.fple_map.texturesets = nil

    end

    rc = save_game_without_rescue_fple(index)

    if $game_map.fple_map # [1.2]

      $game_map.fple_map.texturesets = texturesets

      $game_map.fple_map.textureset = textureset

    end

    return rc

  end

end

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

# ** Game_System

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

class Game_System

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias initialize_fple initialize

    @already_aliased_fple = true

  end

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

  # * Public Instance Variables

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

  attr_accessor :fple # Boolean

  attr_accessor :fple_view_distance # Integer (>0)

  attr_accessor :fple_light_distance # Integer (>=0, 0:deactivated)

  attr_accessor :fple_resolution # Integer (0:max, 1:medium, 2:low, 3:ugly)

  attr_accessor :fple_always_same_res # Boolean

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

  # * Object Initialization

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

  def initialize

    initialize_fple

    self.fple = false

    self.fple_view_distance = FPLE::VIEW_DISTANCE

    self.fple_light_distance = FPLE::LIGHT_DISTANCE

    self.fple_resolution = FPLE::RESOLUTION

    self.fple_always_same_res = FPLE::ALWAYS_SAME_RES

  end

end

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

# ** Game_Temp

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

class Game_Temp

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias initialize_fple initialize

    @already_aliased_fple = true

  end

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

  # * Public Instance Variables

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

  attr_accessor :movement_init # Boolean

  attr_accessor :movement # Boolean

  attr_accessor :movement_dir # Integer {2, 4, 6, 8}

  attr_accessor :last_moving # Boolean

  attr_accessor :force_render # Boolean

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

  # * Object Initialization

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

  def initialize

    initialize_fple

    self.movement_init = false

    self.movement = false

    self.movement_dir = 8

    self.last_moving = false

    self.force_render = false

  end

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

  # * Set view distance

  # param distance : Integer

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

  def set_view(distance)

    if distance < 0 then distance = 0 end

    $game_system.fple_view_distance = distance

    self.force_render = true

  end

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

  # * Set light distance

  # param distance : Integer

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

  def set_light(distance)

    if distance < 0 then distance = 0 end

    $game_system.fple_light_distance = distance

    self.movement = true

    self.movement_dir = 3

  end

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

  # * Increase light distance

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

  def increase_light

    $game_system.fple_light_distance += 1

    self.movement = true

    self.movement_dir = 0

  end

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

  # * Decrease light distance

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

  def decrease_light

    if $game_system.fple_light_distance > 0

      $game_system.fple_light_distance -= 1

    end

    self.movement = true

    self.movement_dir = 1

  end

end

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

# ** Game_Map

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

class Game_Map

public

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias initialize_fple initialize

    alias setup_fple setup

    alias refresh_fple refresh

    @already_aliased_fple = true

  end

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

  # * Public Instance Variables

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

  attr_accessor :surfaces # Array>

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

  # * Object Initialization

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

  def initialize

    initialize_fple

    self.surfaces = []

    @x_ref = 0

    @y_ref = 0

    @distance_cache = {}

    @last_player_pos = [0, 0]

  end

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

  # * Setup

  # param map_id : Integer

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

  def setup(map_id)

    @map_id = map_id

    @map = load_data(sprintf("Data/Map%03d.rvdata2", @map_id))

    if is_fple?

      load_fple_map

      $game_system.fple = true

    elsif $game_system.fple

      $game_system.fple = false

    end

    setup_fple(map_id)

  end

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

  # * Refresh

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

  def refresh

    refresh_fple

    if is_fple?

      unless @fple_map.textureset

        load_fple_map

      end

    end

  end

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

  # * Vérifie s'il s'agit d'une carte FPLE

  # return String

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

  def is_fple?

    return @map.note[/\[fple:\w+\]/]

  end

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

  # * Charge la carte FPLE associée

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

  def load_fple_map

    if @fple_map then @fple_map.dispose end

    @map.note[/\[fple:(\w+)\]/]

    File.open('Data_FPLE/' + $1 + '.fple', "rb") {|file|

      map_data = Marshal.load(file)

      @fple_map = FPLE::Map.new(map_data.width, map_data.height,

      map_data.map_name, map_data.tileset_name, map_data.data,

      map_data.subsets_mapping, map_data.textureset_data)

    }

  end

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

  # * Retourne la carte FPLE associée

  # return FPLE::Map

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

  def fple_map

    @fple_map

  end

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

  # * Retourne le nom du tileset

  # return String

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

  def tileset_name

    if $game_system.fple

      return @fple_map.tileset_name

    else

      return ""

    end

  end

end

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

   def cached_distance(event_id, event_x, event_y)

    player_pos = [$game_player.x, $game_player.y]

    # Clear cache if player moved

    if @last_player_pos != player_pos

      @distance_cache.clear

      @last_player_pos = player_pos

    end

    cache_key = [event_id, event_x, event_y]

    return @distance_cache[cache_key] if @distance_cache.has_key?(cache_key)

    dist_x = (player_pos[0] - event_x).abs

    dist_y = (player_pos[1] - event_y).abs

    distance = Math.sqrt(dist_x * dist_x + dist_y * dist_y)

    @distance_cache[cache_key] = distance

    return distance

  end

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

  # * Recherche les surfaces visibles de la carte en fonction de

  # l'orientation du joueur

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

  def refresh_surfaces

    @current_dir = $game_player.direction

    self.surfaces = []

    @x_ref = $game_player.x

    @y_ref = $game_player.y

    case $game_player.direction

    when 2

      surfaces_temp = refresh_surfaces_down

    when 4

      surfaces_temp = refresh_surfaces_left

    when 6

      surfaces_temp = refresh_surfaces_right

    when 8

      surfaces_temp = refresh_surfaces_up

    end

    # set surfaces z attributes with z-fighting prevention

    surfaces_temp.each {|surface| set_surface_z(surface)}

    surfaces.concat(surfaces_temp)

    # Enhanced sorting with z-fighting prevention

    if @last_surface_count != surfaces.length || $game_temp.force_render

      surfaces.sort! { |a, b|

        z_diff = b[5] - a[5]

        if z_diff.abs < 0.001 # Very close z-values

          # Use additional criteria for stable sorting

          secondary = (b[1].abs + b[2].abs) - (a[1].abs + a[2].abs)

          secondary.zero? ? b.object_id <=> a.object_id : secondary

        else

          z_diff <=> 0

        end

      }

      @last_surface_count = surfaces.length

    end

  end

     def add_character_surfaces_down_with_rotation_fix(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      dy = surface.dy - ($game_player.y << 7)

      dx = ($game_player.x << 7) - surface.dx

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 2)

    end

    return surfaces_temp

  end

  def add_character_surfaces_up_with_rotation_fix(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      dy = ($game_player.y << 7) - surface.dy

      dx = surface.dx - ($game_player.x << 7)

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 8)

    end

    return surfaces_temp

  end

  def add_character_surfaces_left_with_rotation_fix(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      dy = ($game_player.x << 7) - surface.dx

      dx = ($game_player.y << 7) - surface.dy

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 4)

    end

    return surfaces_temp

  end

  def add_character_surfaces_right_with_rotation_fix(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      dy = surface.dx - ($game_player.x << 7)

      dx = surface.dy - ($game_player.y << 7)

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 6)

    end

    return surfaces_temp

  end

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

  # * Add surfaces for single-sided events only during rotation

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

  def add_character_surfaces_down_single_only(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      # Only process single-sided events

      #next if surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

      dy = surface.dy - ($game_player.y << 7)

      dx = ($game_player.x << 7) - surface.dx

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 2)

    end

    return surfaces_temp

  end

  def add_character_surfaces_up_single_only(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      # Only process single-sided events

      #next if surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

      dy = ($game_player.y << 7) - surface.dy

      dx = surface.dx - ($game_player.x << 7)

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 8)

    end

    return surfaces_temp

  end

def add_character_surfaces_left_single_only(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      # Only process single-sided events

      #next if surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

      dy = ($game_player.x << 7) - surface.dx

      dx = ($game_player.y << 7) - surface.dy

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 4)

    end

    return surfaces_temp

  end

  def add_character_surfaces_right_single_only(character_surfaces)

    surfaces_temp = []

    i = $game_system.fple_view_distance

    character_surfaces.each do |surface|

      next if surface.displayed # Skip if already processed

      # Only process single-sided events

      #next if surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

      dy = surface.dx - ($game_player.x << 7)

      dx = surface.dy - ($game_player.y << 7)

      add_character_surfaces(surface, dy, dx, surfaces_temp, i, 6)

    end

    return surfaces_temp

  end

      def add_two_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    # Handle special case where player is at same position as box

        j = i << 7

    if dy.between?(128, j) && dx.between?(-j, j)

    event_id = surface.character.id rescue 0

    base_z_offset = (event_id % 1000) * 0.0001

    distance = Math.sqrt(dy * dy + dx * dx)

    # Determine visible faces based on position

      faces_to_render = []

    # Front face (player looking at object)

    if dy > 32

      faces_to_render << {type: 1, d_align: 0, z_priority: 5, name: :front}

    end

    # Back face

    if dy < -32

      faces_to_render << {type: 1, d_align: 2, z_priority: 0, name: :back}

    end

    # Left face - FIXED: Use proper alignment values

    if dx < -32

      faces_to_render << {type: 2, d_align: 0, z_priority: 4, name: :left}

    end

    # Right face - FIXED: Use proper alignment values

    if dx > 32

      faces_to_render << {type: 2, d_align: 2, z_priority: 1, name: :right}

    end

    # For very close viewing, always show some faces

    if distance < 96

      if faces_to_render.empty?

        faces_to_render << {type: 1, d_align: 0, z_priority: 5, name: :front}

        faces_to_render << {type: 2, d_align: 0, z_priority: 4, name: :left}

      end

    end

    # Render at least one face

    if faces_to_render.empty?

      faces_to_render << {type: 1, d_align: 0, z_priority: 5, name: :front}

    end

    end

    # Render the faces

    faces_to_render.each_with_index do |face_config, face_index|

      side_dy = dy

      side_dx = dx

      # FIXED: Apply position adjustments with proper bounds checking

      if face_config[:type] == 1 # Horizontal face

        if face_config[:d_align] == 0 # Front

          side_dy -= 64

        elsif face_config[:d_align] == 2 # Back

          side_dy += 64

        end

      elsif face_config[:type] == 2 # Vertical face

        if face_config[:d_align] == 0 # Left

          side_dx -= 64

        elsif face_config[:d_align] == 2 # Right

          side_dx += 64

        end

      end

      # Calculate z-modifier

      z_modifier = base_z_offset + (face_config[:z_priority] * 0.008) + (face_index * 0.001)

      surface_data = [0, side_dy, side_dx, 5, 0, 0,

                      surface.bitmap.__id__, face_config[:type],

                      surface.character.fple_v_align, surface.character.fple_stretch,

                      surface.opacity, surface.blend_type,

                      surface.fit, surface.zoom, 0, z_modifier]

      surfaces_temp.push(surface_data)

    end

    surface.displayed = true

  end

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

  # * FIXED: Four-sided surfaces - ensure proper type assignment

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

  def add_four_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    # Handle special case where player is at same position as box

        j = i << 7

    if dy.between?(128, j) && dx.between?(-j, j)

    event_id = surface.character.id rescue 0

    base_z_offset = (event_id % 1000) * 0.0001

    # Always render all 4 sides for 4-sided boxes

    faces_to_render = [

      {type: 1, d_align: 0, z_priority: 3, name: :front},  # Front

      {type: 1, d_align: 2, z_priority: 0, name: :back},   # Back

      {type: 2, d_align: 0, z_priority: 3, name: :left},     # Left

      {type: 2, d_align: 2, z_priority: 1, name: :right},    # Right

    ]

    # Render all faces with strafe-safe positioning

    faces_to_render.each_with_index do |face_config, face_index|

      side_dy = dy

      side_dx = dx

      # FIXED: Apply position adjustments with bounds checking and strafe compensation

      if face_config[:type] == 1 # Horizontal face

        if face_config[:d_align] == 0 # Front

          side_dy -= 64

        elsif face_config[:d_align] == 2 # Back

          side_dy += 64

        end

      elsif face_config[:type] == 2 # Vertical face

        if face_config[:d_align] == 0 # Left

          side_dx -= 64

        elsif face_config[:d_align] == 2 # Right

          side_dx += 64

        end

      end

      # Calculate z-modifier

      z_modifier = base_z_offset + (face_config[:z_priority] * 0.01) + (face_index * 0.001)

      surface_data = [0, side_dy, side_dx, 5, 0, 0,

                      surface.bitmap.__id__, face_config[:type],

                      surface.character.fple_v_align, surface.character.fple_stretch,

                      surface.opacity, surface.blend_type,

                      surface.fit, surface.zoom, 0, z_modifier]

      surfaces_temp.push(surface_data)

    end

    surface.displayed = true

  end

end

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

  # * FIXED: Six-sided surfaces - ensure proper type assignment

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

def add_six_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    j = i << 7

    if dy.between?(128, j) && dx.between?(-j, j)

    event_id = surface.character.id rescue 0

    base_z_offset = (event_id % 1000) * 0.0001

    # Render all 6 sides for maximum visibility

      faces_to_render = [

      {type: 0, d_align: 1, z_priority: 2, name: :center_h}, # Center horizontal

      {type: 1, d_align: 0, z_priority: 4, name: :front},    # Front

      {type: 1, d_align: 2, z_priority: 0, name: :back},     # Back

      {type: 2, d_align: 0, z_priority: 3, name: :left},    # Left

      {type: 2, d_align: 2, z_priority: 1, name: :right},  # Right

    ]

    # Render all faces with strafe protection

    faces_to_render.each_with_index do |face_config, face_index|

      side_dy = dy

      side_dx = dx

      # FIXED: Apply position adjustments with strafe-aware bounds checking

      if face_config[:type] == 1 # Horizontal face

        if face_config[:d_align] == 0 # Front

          side_dy -= 64

        elsif face_config[:d_align] == 2 # Back

          side_dy += 64

        end

      elsif face_config[:type] == 2 # Vertical face

        if face_config[:d_align] == 0 # Left

          side_dx -= 64

        elsif face_config[:d_align] == 2 # Right

          side_dx += 64

        end

      end

      # Calculate z-modifier

      z_modifier = base_z_offset + (face_config[:z_priority] * 0.008) + (face_index * 0.001)

      surface_data = [0, side_dy, side_dx, 5, 0, 0,

                      surface.bitmap.__id__, face_config[:type],

                      surface.character.fple_v_align, surface.character.fple_stretch,

                      surface.opacity, surface.blend_type,

                      surface.fit, surface.zoom, 0, z_modifier]

      surfaces_temp.push(surface_data)

    end

    surface.displayed = true

  end

  end

    # Render all 6 sides for maximum visibility

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

  # * Calcul de la priorité d'affichage d'une surface

  # param surface : Array

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

  def set_surface_z(surface)

    if surface[3] < 5 # map surfaces

      base_z = (surface[1].abs << 5) + surface[2].abs

      # Apply rotation compensation for map surfaces

      if FPLE.angle > 0

        rotation_factor = FPLE.angle / 90.0

        # Increase z-depth for surfaces during rotation to prevent bleeding

        base_z += (rotation_factor * 1000).to_i

      end

      surface[5] = base_z

    else # character surfaces

      base_z = (surface[1].abs >> 1) + (surface[2].abs >> 6) - 2

      # Check if surface has z-modifier (from multi-sided rendering)

      z_modifier = surface[15] || 0

      # Enhanced rotation compensation for character surfaces

      if FPLE.angle > 0

        rotation_factor = FPLE.angle / 90.0

        # Push character surfaces further back during rotation

        rotation_penalty = rotation_factor * 500

        # Additional penalty based on distance from player

        distance_penalty = Math.sqrt(surface[1] * surface[1] + surface[2] * surface[2]) * 0.1

        base_z += (rotation_penalty + distance_penalty).to_i

      end

      # Surface type and alignment offsets

      type_offset = surface[7] || 0

      align_offset = surface[8] || 0

      z_offset = case type_offset

      when 1 # Horizontal walls

        case surface[2] <=> 0

        when -1 then 0.4  # Left side

        when 0 then 0.2   # Center  

        when 1 then 0.0   # Right side

        end

      when 2 # Vertical walls

        case surface[1] <=> 0

        when -1 then 0.3  # Front

        when 0 then 0.1   # Center

        when 1 then -0.1  # Back

        end

      else

        0 # Default for type 0

      end

      # Vertical alignment offset

    if $game_temp.movement_dir == 10 && $game_player.moving?

      v_align_offset = 0

    else

      v_align_offset = case align_offset

      when 0 then 0.03   # Top

      when 1 then 0.01   # Middle

      when 2 then -32.01 # Bottom

      else 0

      end

    end

    surface[5] = base_z.to_f + z_offset + v_align_offset + z_modifier

  end

end

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

  # * Recherche les surfaces visibles des évènements en fonction de

  # l'orientation du joueur

  # param character_surfaces : Array

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

# This method updates the list of character surfaces based on visibility and player direction.

public

def refresh_character_surfaces(character_surfaces)

    return if character_surfaces.empty?

    max_dist = ($game_system.fple_view_distance || 10) + 3  # Large buffer

    visible_surfaces = character_surfaces.select do |surface|

      next false unless surface.character && surface.visible && surface.opacity > 0

      # Very generous distance-based filtering

      char = surface.character

      dist_x = ($game_player.x - char.x).abs

      dist_y = ($game_player.y - char.y).abs

      dist_x <= max_dist && dist_y <= max_dist

    end

    visible_surfaces = character_surfaces.select { |s|

      s.character && s.visible && s.opacity > 0

    }

    clear_character_surfaces(visible_surfaces)

    # During rotation, we need to render from multiple directions

    if FPLE.angle > 0

      # For multi-sided events during rotation, only render once from current direction

      # to prevent duplicate/rotating surfaces

      current_surfaces = case $game_player.direction

      when 2 then add_character_surfaces_down_with_rotation_fix(visible_surfaces)

      when 4 then add_character_surfaces_left_with_rotation_fix(visible_surfaces)

      when 6 then add_character_surfaces_right_with_rotation_fix(visible_surfaces)

      when 8 then add_character_surfaces_up_with_rotation_fix(visible_surfaces)

      end

      # Only add next direction surfaces for single-sided events

      clear_character_surfaces_for_single_sided(visible_surfaces)

      next_surfaces = case $game_player.direction

      when 2 then add_character_surfaces_right_single_only(visible_surfaces)

      when 4 then add_character_surfaces_down_single_only(visible_surfaces)

      when 6 then add_character_surfaces_up_single_only(visible_surfaces)

      when 8 then add_character_surfaces_left_single_only(visible_surfaces)

      end

      surfaces_temp = current_surfaces + next_surfaces

    else

      # Normal rendering - single direction

      surfaces_temp = case $game_player.direction

      when 2 then add_character_surfaces_down(visible_surfaces)

      when 4 then add_character_surfaces_left(visible_surfaces)

      when 6 then add_character_surfaces_right(visible_surfaces)

      when 8 then add_character_surfaces_up(visible_surfaces)

      else []

      end

    end

    surfaces_temp.each { |surface| set_surface_z(surface) }

    @surfaces.concat(surfaces_temp)

    #Old#@surfaces.sort! { |a, b| b[5] - a[5] }

      # Enhanced sorting

    @surfaces.sort! do |a, b|

      z_diff = b[5] - a[5]

      if z_diff.abs < 0.0001

        (b[1].abs + b[2].abs) - (a[1].abs + a[2].abs)

      else

        z_diff <=> 0

      end

    end

  end

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

  # * Réinitialise l'indicateur d'affichage des surfaces liées aux évènements

  # param character_surfaces : Array

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

  def clear_character_surfaces(character_surfaces)

    character_surfaces.each {|surface| surface.displayed = false}

  end

  def clear_character_surfaces_for_single_sided(character_surfaces)

    character_surfaces.each do |surface|

      # Only clear single-sided events - keep multi-sided events as displayed

      unless surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

        surface.displayed = false

      end

    end

  end

  def cleanup_distant_surfaces

    return unless @surfaces

    # Only cleanup if we have a lot of surfaces

    max_surfaces = 300 # Very generous limit

    if @surfaces.length > max_surfaces

      # Keep only the closest surfaces

      @surfaces.sort_by! { |s| s[1].abs + s[2].abs }

      @surfaces = @surfaces.first(max_surfaces)

    end

  end

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

  # * Vérifie la visibilité d'une surface liée à un évènement et l'ajoute

  # à la liste des surfaces à afficher le cas échéant

  # param surface : FPLE::Surface_Characters

  # param dy : Integer

  # param dx : Integer

  # param surfaces_temp : Array>

  # param i : Integer

  # param dir : Integer

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

# This method adds a character surface to the list for rendering if it is visible.

# `surface`: The FPLE surface object for the character.

# `dy`: The change in y-coordinate from the player.

# `dx`: The change in x-coordinate from the player.

# `surfaces_temp`: The array to which the new surface will be added.

# `i`: The view distance index used for calculation.

# `dir`: The player's direction.

def add_character_surfaces(surface, dy, dx, surfaces_temp, i, dir)

  return unless surface.character && surface.character.fple_type

  # Distance culling - more generous for multi-sided events

  distance_sq = dy * dy + dx * dx

  max_distance = $game_system.fple_view_distance || 10

  # Use larger buffer for multi-sided events to prevent edge clipping

  if surface.character.fple_four_side || surface.character.fple_six_side || surface.character.fple_two_side

    rotation_buffer = FPLE.angle > 0 ? 1.5 : 1.3

  else

    rotation_buffer = FPLE.angle > 0 ? 2.0 : 1.0

  end

  max_distance_sq = (max_distance * 96 * rotation_buffer) ** 2

  return if distance_sq > max_distance_sq

  # Early opacity check

  return if surface.opacity <= 0

  # Handle multi-sided boxes

  if surface.character.fple_two_side

    add_two_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    return

  elsif surface.character.fple_four_side

    add_four_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    return

  elsif surface.character.fple_six_side

    add_six_sided_surfaces(surface, dy, dx, surfaces_temp, i, dir)

    return

  end

  # Original single-surface logic for regular events

  j = i << 7

  if dy == 0 && dx == 0 && surface.character.fple_type == 0 && surface.character.fple_one_side == false

    surface.set_relative_attributes(dir)

    safe_dy = 128

    surface_data = [0, safe_dy, 0, 5, 0, 0,

                    surface.bitmap.__id__,

                    0, # Keep type 0 for face-player events at same position

                    surface.character.fple_v_align,

                    surface.character.fple_stretch,

                    surface.opacity,

                    surface.blend_type,

                    surface.fit,

                    surface.zoom,

                    surface.mirror]

    surfaces_temp.push(surface_data)

    surface.displayed = true

    elsif dy.between?(128, j) && dx.between?(-j, j)

    # Position adjustments for wall types

    if surface.v_align == 2

      dy -= 16 unless surface.fit == 1

    end

    surface.set_relative_attributes(dir)

    if surface.type == 1

      if surface.d_align == 0

        dy -= 64

      elsif surface.d_align == 2

        dy += 64

      elsif surface.d_align == 1 && surface.v_align == 2

        dy -= 16 unless $game_player.moving?

      end

    elsif surface.type == 2

      if surface.d_align == 0

        dx -= 64

      elsif surface.d_align == 2

        dx += 64

      elsif surface.d_align == 1 && surface.v_align == 2

        dx -= 16 unless $game_player.moving?

      end

    end

    surface_data = [0, dy, dx, 5, 0, 0,

                    surface.bitmap.__id__, surface.type,

                    surface.v_align, surface.character.fple_stretch,

                    surface.opacity, surface.blend_type,

                    surface.fit, surface.zoom, surface.mirror]

    surfaces_temp.push(surface_data)

    surface.displayed = true

  end

end

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

def should_render_one_side_event(character, player_dir)

  return true unless character.fple_one_side

  # Get the event's original type

  original_type = character.fple_type

  case original_type

  when 0 # Always face player - render from all directions

    return true

  when 1 # Horizontal wall in editor view

    # Only render when looking from north or south

    return [2, 8].include?(player_dir)

  when 2 # Vertical wall in editor view

    # Only render when looking from east or west

    return [4, 6].include?(player_dir)

  end

  return true

end

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

def should_render_two_side_event(character, player_dir)

  return true unless character.fple_two_side

  # Get the event's original type

  original_type = character.fple_type

  case original_type

  when 0 # Always face player - render from all directions

    return true

  when 1 # Horizontal wall in editor view

    # Only render when looking from north or south

    return [2, 8].include?(player_dir)

  when 2 # Vertical wall in editor view

    # Only render when looking from east or west

    return [4, 6].include?(player_dir)

  end

  return true

end

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

  # * Recherche les surfaces liées à un évènement visibles quand le joueur est

  # orienté vers le bas

  # param character_surfaces : Array

  # return Array>

  #----------------------------z

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

  # * Recherche les surfaces liées à un évènement visibles quand le joueur est

  # orienté vers le haut

  # param character_surfaces : Array

  # return Array>

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

def add_character_surfaces_up(character_surfaces)

  surfaces_temp = []

  i = $game_system.fple_view_distance

  character_surfaces.each {|surface|

    if surface.displayed then next end

    # Check directional visibility for 2-side events

    next unless should_render_two_side_event(surface.character, 8)

    dy = ($game_player.y << 7) - surface.dy

    dx = surface.dx - ($game_player.x << 7)

    add_character_surfaces(surface, dy, dx, surfaces_temp, i, 8)

  }

  return surfaces_temp

end

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

  # * Recherche les surfaces liées à un évènement visibles quand le joueur est

  # orienté vers le bas

  # param character_surfaces : Array

  # return Array>

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

def add_character_surfaces_down(character_surfaces)

  surfaces_temp = []

  i = $game_system.fple_view_distance

  character_surfaces.each {|surface|

    if surface.displayed then next end

    # Check directional visibility for 2-side events

    next unless should_render_two_side_event(surface.character, 2)

    dy = surface.dy - ($game_player.y << 7)

    dx = ($game_player.x << 7) - surface.dx

    add_character_surfaces(surface, dy, dx, surfaces_temp, i, 2)

  }

  return surfaces_temp

end

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

  # * Recherche les surfaces liées à un évènement visibles quand le joueur est

  # orienté vers la gauche

  # param character_surfaces : Array

  # return Array>

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

def add_character_surfaces_left(character_surfaces)

  surfaces_temp = []

  i = $game_system.fple_view_distance

  character_surfaces.each {|surface|

    if surface.displayed then next end

    # Check directional visibility for 2-side events

    next unless should_render_two_side_event(surface.character, 4)

    dy = ($game_player.x << 7) - surface.dx

    dx = ($game_player.y << 7) - surface.dy

    add_character_surfaces(surface, dy, dx, surfaces_temp, i, 4)

  }

  return surfaces_temp

end

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

  # * Recherche les surfaces liées à un évènement visibles quand le joueur est

  # orienté vers la droite

  # param character_surfaces : Array

  # return Array>

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

def add_character_surfaces_right(character_surfaces)

  surfaces_temp = []

  i = $game_system.fple_view_distance

  character_surfaces.each {|surface|

    if surface.displayed then next end

    # Check directional visibility for 2-side events

    next unless should_render_two_side_event(surface.character, 6)

    dy = surface.dx - ($game_player.x << 7)

    dx = surface.dy - ($game_player.y << 7)

    add_character_surfaces(surface, dy, dx, surfaces_temp, i, 6)

  }

  return surfaces_temp

end

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

  # * Recherche les surfaces visibles quand le joueur tourne vers la droite

  # param character_surfaces : Array

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

def position_occluded_during_rotation?(x, y, player_x, player_y, check_direction)

  # Calculate the path from player to target position

  dx = x - player_x

  dy = y - player_y

    if @fple_map.get_data(x, y)[0] > 0

      return false unless $game_map.region_id($game_player.x, $game_player.y) == 0

    else

  end

  # Don't occlude events that are directly adjacent (doors on walls)

  if dx.abs <= 1 && dy.abs <= 1 && (dx.abs + dy.abs) == 1

    return false

  end

  # For single-tile distances, check adjacent walls

  if dx.abs <= 1 && dy.abs <= 1

    case check_direction

    when 2 # Down

      # Check for walls between player and target going down

      return @fple_map.get_data(player_x, player_y + 1)[0] > 0 if dy > 0

    when 4 # Left  

      # Check for walls between player and target going left

      return @fple_map.get_data(player_x - 1, player_y)[0] > 0 if dx < 0

    when 6 # Right

      # Check for walls between player and target going right  

      return @fple_map.get_data(player_x + 1, player_y)[0] > 0 if dx > 0

    when 8 # Up

      # Check for walls between player and target going up

      return @fple_map.get_data(player_x, player_y - 1)[0] > 0 if dy < 0

    end

  end

  # For longer distances, use line-of-sight checking

  return line_of_sight_blocked?(player_x, player_y, x, y)

end

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

# * Check if line of sight is blocked by walls

# param x1, y1 : Integer - start coordinates

# param x2, y2 : Integer - end coordinates  

# return Boolean - true if blocked

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

def line_of_sight_blocked?(x1, y1, x2, y2)

  # Simple bresenham-like algorithm to check for wall blocking

  dx = (x2 - x1).abs

  dy = (y2 - y1).abs

  return false if dx == 0 && dy == 0

  x_step = x1 < x2 ? 1 : -1

  y_step = y1 < y2 ? 1 : -1

  # Check key points along the path

  if dx > dy

    # More horizontal movement

    (1..dx).each do |i|

      check_x = x1 + (i * x_step)

      check_y = y1 + ((i * dy * y_step) / dx)

      return true if @fple_map.get_data(check_x, check_y)[0] > 0

    end

  else

    # More vertical movement  

    (1..dy).each do |i|

      check_x = x1 + ((i * dx * x_step) / dy)

      check_y = y1 + (i * y_step)

      return true if @fple_map.get_data(check_x, check_y)[0] > 0

    end

  end

  false

end

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

# * Enhanced character surface filtering with occlusion

# param character_surfaces : Array

# param player_dir : Integer - current player direction

# param rotation_dir : Integer - direction of rotation (next direction)

# return Array - filtered surfaces

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

def filter_character_surfaces_with_occlusion(character_surfaces, player_dir, rotation_dir = nil)

  return [] if character_surfaces.empty?

  player_x = $game_player.x

  player_y = $game_player.y

  filtered_surfaces = []

  character_surfaces.each do |surface|

    next unless surface.character && surface.visible && surface.opacity > 0

    char_x = surface.character.x

    char_y = surface.character.y

    # Skip if too distant

    dist_x = (player_x - char_x).abs  

    dist_y = (player_y - char_y).abs

    max_dist = $game_system.fple_view_distance + 2

    next if dist_x > max_dist || dist_y > max_dist

    # Check occlusion for current direction

    current_occluded = position_occluded_during_rotation?(char_x, char_y, player_x, player_y, player_dir)

    # Check occlusion for rotation direction if specified

    rotation_occluded = rotation_dir ?

      position_occluded_during_rotation?(char_x, char_y, player_x, player_y, rotation_dir) : false

    # Include surface if visible from either direction

    unless current_occluded && rotation_occluded

      filtered_surfaces << surface

    end

  end

  filtered_surfaces

end

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

# * Recherche les surfaces visibles quand le joueur tourne vers la droite

# param character_surfaces : Array

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

def refresh_surfaces_turn_right(character_surfaces)

  @current_dir = $game_player.direction

  self.surfaces = []

  @x_ref = $game_player.x

  @y_ref = $game_player.y

  surfaces_temp = refresh_current_surface

  # Filter character surfaces with occlusion checking

  filtered_surfaces = filter_character_surfaces_with_occlusion(character_surfaces, @current_dir,

    case @current_dir

    when 2 then 6  # Down -> Right

    when 4 then 2  # Left -> Down  

    when 6 then 8  # Right -> Up

    when 8 then 4  # Up -> Left

    end)

  clear_character_surfaces(filtered_surfaces)

  case $game_player.direction

  when 2

    surfaces_temp1 = refresh_surfaces_down

    @current_dir = 6

    surfaces_temp2 = refresh_surfaces_right(false)

    @current_dir = 2

    surfaces_temp1 += add_character_surfaces_down(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_right(filtered_surfaces)

  when 4

    surfaces_temp1 = refresh_surfaces_left

    @current_dir = 2

    surfaces_temp2 = refresh_surfaces_down(false)

    @current_dir = 4

    surfaces_temp1 += add_character_surfaces_left(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_down(filtered_surfaces)

  when 6

    surfaces_temp1 = refresh_surfaces_right

    @current_dir = 8

    surfaces_temp2 = refresh_surfaces_up(false)

    @current_dir = 6

    surfaces_temp1 += add_character_surfaces_right(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_up(filtered_surfaces)

  when 8

    surfaces_temp1 = refresh_surfaces_up

    @current_dir = 4

    surfaces_temp2 = refresh_surfaces_left(false)

    @current_dir = 8

    surfaces_temp1 += add_character_surfaces_up(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_left(filtered_surfaces)

  end

  surfaces_temp1.each {|surface| adjust_surface_for_rotation(surface)}

  # set surfaces z attributes

  (surfaces_temp + surfaces_temp1 + surfaces_temp2).each {|surface|

    set_surface_z(surface)

  }

  surfaces.concat(surfaces_temp + surfaces_temp1 + surfaces_temp2)

  surfaces.sort! {|a, b| b[5] - a[5]}

end

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

# * Recherche les surfaces visibles quand le joueur tourne vers la gauche

# param character_surfaces : Array

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

def refresh_surfaces_turn_left(character_surfaces)

  @current_dir = $game_player.direction

  self.surfaces = []

  @x_ref = $game_player.x

  @y_ref = $game_player.y

  surfaces_temp = refresh_current_surface

  # Filter character surfaces with occlusion checking

  filtered_surfaces = filter_character_surfaces_with_occlusion(character_surfaces, @current_dir,

    case @current_dir

    when 2 then 4  # Down -> Left

    when 4 then 8  # Left -> Up

    when 6 then 2  # Right -> Down

    when 8 then 6  # Up -> Right

    end)

  clear_character_surfaces(filtered_surfaces)

  case $game_player.direction

  when 2

    @current_dir = 4

    surfaces_temp1 = refresh_surfaces_left

    @current_dir = 2

    surfaces_temp2 = refresh_surfaces_down(false)

    surfaces_temp1 += add_character_surfaces_left(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_down(filtered_surfaces)

  when 4

    @current_dir = 8

    surfaces_temp1 = refresh_surfaces_up

    @current_dir = 4

    surfaces_temp2 = refresh_surfaces_left(false)

    surfaces_temp1 += add_character_surfaces_up(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_left(filtered_surfaces)

  when 6

    @current_dir = 2

    surfaces_temp1 = refresh_surfaces_down

    @current_dir = 6

    surfaces_temp2 = refresh_surfaces_right(false)

    surfaces_temp1 += add_character_surfaces_down(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_right(filtered_surfaces)

  when 8

    @current_dir = 6

    surfaces_temp1 = refresh_surfaces_right

    @current_dir = 8

    surfaces_temp2 = refresh_surfaces_up(false)

    surfaces_temp1 += add_character_surfaces_right(filtered_surfaces)

    surfaces_temp2 += add_character_surfaces_up(filtered_surfaces)

  end

  surfaces_temp1.each {|surface| adjust_surface_for_rotation(surface)}

  # set surfaces z attributes

  (surfaces_temp + surfaces_temp1 + surfaces_temp2).each {|surface|

    set_surface_z(surface)

  }

  surfaces.concat(surfaces_temp + surfaces_temp1 + surfaces_temp2)

  surfaces.sort! {|a, b| b[5] - a[5]}

end

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

# * Enhanced turn up method (if needed for your system)

# param character_surfaces : Array

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

def refresh_surfaces_turn_up(character_surfaces)

  @current_dir = $game_player.direction

  self.surfaces = []

  @x_ref = $game_player.x

  @y_ref = $game_player.y

  surfaces_temp = refresh_current_surface

  # Filter character surfaces with occlusion checking

  filtered_surfaces = filter_character_surfaces_with_occlusion(character_surfaces, @current_dir, 8)

  clear_character_surfaces(filtered_surfaces)

  # Render current direction surfaces

  surfaces_temp1 = case $game_player.direction

  when 2 then refresh_surfaces_down

  when 4 then refresh_surfaces_left  

  when 6 then refresh_surfaces_right

  when 8 then refresh_surfaces_up

  else []

  end

  # Render up direction surfaces

  @current_dir = 8

  surfaces_temp2 = refresh_surfaces_up(false)

  @current_dir = $game_player.direction

  # Add character surfaces

  surfaces_temp1 += case $game_player.direction

  when 2 then add_character_surfaces_down(filtered_surfaces)

  when 4 then add_character_surfaces_left(filtered_surfaces)

  when 6 then add_character_surfaces_right(filtered_surfaces)

  when 8 then add_character_surfaces_up(filtered_surfaces)

  else []

  end

  surfaces_temp2 += add_character_surfaces_up(filtered_surfaces)

  surfaces_temp1.each {|surface| adjust_surface_for_rotation(surface)} unless $game_player.direction == 8

  # set surfaces z attributes

  (surfaces_temp + surfaces_temp1 + surfaces_temp2).each {|surface|

    set_surface_z(surface)

  }

  surfaces.concat(surfaces_temp + surfaces_temp1 + surfaces_temp2)

  surfaces.sort! {|a, b| b[5] - a[5]}

end

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

# * Enhanced turn down method (if needed for your system)  

# param character_surfaces : Array

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

def refresh_surfaces_turn_down(character_surfaces)

  @current_dir = $game_player.direction

  self.surfaces = []

  @x_ref = $game_player.x

  @y_ref = $game_player.y

  surfaces_temp = refresh_current_surface

  # Filter character surfaces with occlusion checking

  filtered_surfaces = filter_character_surfaces_with_occlusion(character_surfaces, @current_dir, 2)

  clear_character_surfaces(filtered_surfaces)

  # Render current direction surfaces

  surfaces_temp1 = case $game_player.direction

  when 2 then refresh_surfaces_down

  when 4 then refresh_surfaces_left

  when 6 then refresh_surfaces_right

  when 8 then refresh_surfaces_up

  else []

  end

  # Render down direction surfaces

  @current_dir = 2

  surfaces_temp2 = refresh_surfaces_down(false)

  @current_dir = $game_player.direction

  # Add character surfaces

  surfaces_temp1 += case $game_player.direction

  when 2 then add_character_surfaces_down(filtered_surfaces)

  when 4 then add_character_surfaces_left(filtered_surfaces)

  when 6 then add_character_surfaces_right(filtered_surfaces)

  when 8 then add_character_surfaces_up(filtered_surfaces)

  else []

  end

  surfaces_temp2 += add_character_surfaces_down(filtered_surfaces)

  surfaces_temp1.each {|surface| adjust_surface_for_rotation(surface)} unless $game_player.direction == 2

  # set surfaces z attributes

  (surfaces_temp + surfaces_temp1 + surfaces_temp2).each {|surface|

    set_surface_z(surface)

  }

  surfaces.concat(surfaces_temp + surfaces_temp1 + surfaces_temp2)

  surfaces.sort! {|a, b| b[5] - a[5]}

end

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

  # * Correction des attributs d'une surface visible pendant une rotation

  # param surface : Array

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

  def adjust_surface_for_rotation(surface)

    if surface[3] < 5

      dy = surface[1]

      surface[1] = -surface[2]

      surface[2] = dy

      if surface[3] < 2

        surface[3] = 1 - surface[3]

      end

    else

      if surface[7] > 0

        surface[7] = 3 - surface[7]

      end  

      dy = surface[1]

      surface[1] = -surface[2]

      surface[2] = dy

    end

  end

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

  # * Recherche des surfaces visibles en déplacement latéral

  # param offset : Integer

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

  def refresh_surfaces_strafe(offset)

    @current_dir = $game_player.direction

    @x_ref = $game_player.x

    @y_ref = $game_player.y

    case $game_player.direction

    when 2

      @x_ref -= offset

      surfaces_temp = refresh_surfaces_down_strafe

    when 4

      @y_ref -= offset

      surfaces_temp = refresh_surfaces_left_strafe

    when 6

      @y_ref += offset

      surfaces_temp = refresh_surfaces_right_strafe

    when 8

      @x_ref += offset

      surfaces_temp = refresh_surfaces_up_strafe

    end

    # set surfaces z attributes

    surfaces_temp.each {|surface| set_surface_z(surface)}

    surfaces.concat(surfaces_temp)

    surfaces.sort! {|a, b| b[5] - a[5]}

  end

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

  # * Rafraîchit la surface à la position du joueur

  # return Array>

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

  def refresh_current_surface

    surfaces_temp = []

    get_surface_ground(surfaces_temp, @x_ref, @y_ref, 0, 0)

    return surfaces_temp

  end

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

  # * Recherche les surfaces visibles de la carte quand le joueur est

  # orienté vers le haut

  # param right_ground : Boolean

  # return Array>

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

def refresh_surfaces_up(right_ground = true)

  surfaces_temp = []

  base_distance = $game_system.fple_view_distance

  # Add extra tiles during rotation

  i = FPLE.angle > 0 ? base_distance + 1 : base_distance

  while i > 0

    # peripherical ground/ceiling sprites

    get_surface_ground(surfaces_temp, @x_ref - i, @y_ref - i, i << 1, -i << 1)

    if right_ground

      get_surface_ground(surfaces_temp, @x_ref + i, @y_ref - i, i << 1, i << 1)

    end

    klim = i - 1

    (-klim..klim).each {|k|

      add_surfaces(surfaces_temp, @x_ref + k, @y_ref - i, i << 1, k << 1, 0, 1)

    }

    i -= 1

  end

  return surfaces_temp

end

def refresh_surfaces_down(right_ground = true)

  surfaces_temp = []

  base_distance = $game_system.fple_view_distance

  # Add extra tiles during rotation

  i = FPLE.angle > 0 ? base_distance + 1 : base_distance

  while i > 0

    # peripherical ground sprites

    get_surface_ground(surfaces_temp, @x_ref + i, @y_ref + i, i << 1, -i << 1)

    if right_ground

      get_surface_ground(surfaces_temp, @x_ref - i, @y_ref + i, i << 1, i << 1)

    end

    klim = i - 1

    (-klim..klim).each {|k|

      add_surfaces(surfaces_temp, @x_ref - k, @y_ref + i, i << 1, k << 1, 0, -1)

    }

    i -= 1

  end

  return surfaces_temp

end

def refresh_surfaces_left(right_ground = true)

  surfaces_temp = []

  base_distance = $game_system.fple_view_distance

  # Add extra tiles during rotation

  i = FPLE.angle > 0 ? base_distance + 1 : base_distance

  while i > 0

    # peripherical ground sprites

    get_surface_ground(surfaces_temp, @x_ref - i, @y_ref + i, i << 1, -i << 1)

    if right_ground

      get_surface_ground(surfaces_temp, @x_ref - i, @y_ref - i, i << 1, i << 1)

    end

    klim = i - 1

    (-klim..klim).each {|k|

      add_surfaces(surfaces_temp, @x_ref - i, @y_ref - k, i << 1, k << 1, 1, 0)

    }

    i -= 1

  end

  return surfaces_temp

end

def refresh_surfaces_right(right_ground = true)

  surfaces_temp = []

  base_distance = $game_system.fple_view_distance

  # Add extra tiles during rotation

  i = FPLE.angle > 0 ? base_distance + 1 : base_distance

  while i > 0

    # peripherical ground sprites

    get_surface_ground(surfaces_temp, @x_ref + i, @y_ref - i, i << 1, -i << 1)

    if right_ground

      get_surface_ground(surfaces_temp, @x_ref + i, @y_ref + i, i << 1, i << 1)

    end

    klim = i - 1

    (-klim..klim).each {|k|

      add_surfaces(surfaces_temp, @x_ref + i, @y_ref + k, i << 1, k << 1, -1, 0)

    }

    i -= 1

  end

  return surfaces_temp

end

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

  # * Vérifie si un sol ou un plafond doit être affiché

  # param surfaces_temp : Array>

  # param x : Integer

  # param y : Integer

  # param dy : Integer

  # param dx : Integer

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

  def get_surface_ground(surfaces_temp, x, y, dy, dx)

    if @fple_map.get_data(x, y)[0] == 0 # no wall tile

      add_surface_ground(surfaces_temp, x, y, dy, dx)

    end

  end

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

  # * Ajoute une surface de sol ou de plafond qui doit être affichée

  # param surfaces_temp : Array>

  # param x : Integer

  # param y : Integer

  # param dy : Integer

  # param dx : Integer

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

  def add_surface_ground(surfaces_temp, x, y, dy, dx)

    g_texture_id = @fple_map.get_data(x, y)[1]

    c_texture_id = @fple_map.get_data(x, y)[19]

    if @fple_map.is_texture_id_valid?(g_texture_id)

      if @fple_map.is_texture_id_valid?(c_texture_id)

        surfaces_temp.push([g_texture_id, dy, dx, 4, c_texture_id, 0,

        @fple_map.get_textureset_id(g_texture_id),

        @fple_map.get_textureset_width(g_texture_id),

        @fple_map.get_textureset_id(c_texture_id),

        @fple_map.get_textureset_width(c_texture_id)])

      else

        surfaces_temp.push([g_texture_id, dy, dx, 2, 0, 0,

        @fple_map.get_textureset_id(g_texture_id),

        @fple_map.get_textureset_width(g_texture_id), 0, 8])

      end

    elsif @fple_map.is_texture_id_valid?(c_texture_id)

      surfaces_temp.push([c_texture_id, dy, dx, 3, 0, 0,

      @fple_map.get_textureset_id(c_texture_id),

      @fple_map.get_textureset_width(c_texture_id), 0, 8])

    end

  end

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

  # * Recherche des surfaces visibles

  # param surfaces_temp : Array>

  # param x : Integer

  # param y : Integer

  # param dy : Integer

  # param dx : Integer

  # param oy : Integer

  # param ox : Integer

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

  def add_surfaces(surfaces_temp, x, y, dy, dx, ox, oy)

    if @fple_map.get_data(x, y)[0] > 0 # wall tile

      if @fple_map.get_data(x + ox, y + oy)[0] == 0 # --> visible !

        texture_id = @fple_map.get_data(x, y)[

        FPLE::MAP_SIDES[@current_dir - 1 >> 1]]

        if @fple_map.is_texture_id_valid?(texture_id)

          surfaces_temp.push([texture_id, dy - 1, dx, 1, 0, 0,

          @fple_map.get_textureset_id(texture_id),

          @fple_map.get_textureset_width(texture_id), 0, 8])

        end

      end

    else

      # ground/ceiling sprite

      add_surface_ground(surfaces_temp, x, y, dy, dx)

      # side walls

      if dx <= 0 # left

        if @fple_map.get_data(x - oy, y + ox)[0] > 0 # side wall tile

          texture_id = @fple_map.get_data(x - oy, y + ox)[

          FPLE::MAP_SIDES_LEFT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, dy, dx - 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

      if dx >= 0 # right

        if @fple_map.get_data(x + oy, y - ox)[0] > 0 # side wall tile

          texture_id = @fple_map.get_data(x + oy, y - ox)[

          FPLE::MAP_SIDES_RIGHT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, dy, dx + 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

    end

  end

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

  # * Recherche des surfaces visibles en déplacement latéral quand le

  # joueur est orienté vers le haut

  # return Array>

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

  def refresh_surfaces_up_strafe

    surfaces_temp = []

    i = $game_system.fple_view_distance

    while i > 0

      get_surface_ground(surfaces_temp, @x_ref + i + 1, @y_ref - i, i << 1,

      i + 1 << 1)

      add_surfaces_strafe(surfaces_temp, @x_ref + i,  @y_ref - i, i << 1, 0, 1)

      # middle side wall

      if @fple_map.get_data(@x_ref + 1, @y_ref - i)[0] == 0 # no wall tile

        if @fple_map.get_data(@x_ref, @y_ref - i)[0] > 0 # side wall tile (Left)

          texture_id = @fple_map.get_data(@x_ref, @y_ref - i)[

          FPLE::MAP_SIDES_LEFT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, i << 1, 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

      i -= 1

    end

    return surfaces_temp

  end

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

  # * Recherche des surfaces visibles en déplacement latéral quand le

  # joueur est orienté vers le bas

  # return Array>

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

  def refresh_surfaces_down_strafe

    surfaces_temp = []

    i = $game_system.fple_view_distance

    while i > 0

      get_surface_ground(surfaces_temp, @x_ref - i - 1, @y_ref + i, i << 1,

      i + 1 << 1)

      add_surfaces_strafe(surfaces_temp, @x_ref - i,  @y_ref + i, i << 1, 0, -1)

      # middle side wall

      if @fple_map.get_data(@x_ref - 1, @y_ref + i)[0] == 0 # no wall tile

        if @fple_map.get_data(@x_ref, @y_ref + i)[0] > 0 # side wall tile (Left)

          texture_id = @fple_map.get_data(@x_ref, @y_ref + i)[

          FPLE::MAP_SIDES_LEFT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, i << 1, 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

      i -= 1

    end

    return surfaces_temp

  end

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

  # * Recherche des surfaces visibles en déplacement latéral quand le

  # joueur est orienté vers la gauche

  # return Array>

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

  def refresh_surfaces_left_strafe

    surfaces_temp = []

    i = $game_system.fple_view_distance

    while i > 0

      get_surface_ground(surfaces_temp, @x_ref - i, @y_ref - i - 1, i << 1,

      i + 1 << 1)

      add_surfaces_strafe(surfaces_temp, @x_ref - i,  @y_ref - i, i << 1, 1, 0)

      # middle side wall

      if @fple_map.get_data(@x_ref - i, @y_ref - 1)[0] == 0 # no wall tile

        if @fple_map.get_data(@x_ref - i, @y_ref)[0] > 0 # side wall tile (Left)

          texture_id = @fple_map.get_data(@x_ref - i, @y_ref)[

          FPLE::MAP_SIDES_LEFT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, i << 1, 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

      i -= 1

    end

    return surfaces_temp

  end

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

  # * Recherche des surfaces visibles en déplacement latéral quand le

  # joueur est orienté vers la droite

  # return Array>

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

  def refresh_surfaces_right_strafe

    surfaces_temp = []

    i = $game_system.fple_view_distance

    while i > 0

      get_surface_ground(surfaces_temp, @x_ref + i, @y_ref + i + 1, i << 1,

      i + 1 << 1)

      add_surfaces_strafe(surfaces_temp, @x_ref + i,  @y_ref + i, i << 1, -1, 0)

      # middle side wall

      if @fple_map.get_data(@x_ref + i, @y_ref + 1)[0] == 0 # no wall tile

        if @fple_map.get_data(@x_ref + i, @y_ref)[0] > 0 # side wall tile (Left)

          texture_id = @fple_map.get_data(@x_ref + i, @y_ref)[

          FPLE::MAP_SIDES_LEFT[@current_dir - 1 >> 1]]

          if @fple_map.is_texture_id_valid?(texture_id)

            surfaces_temp.push([texture_id, i << 1, 1, 0, 0, 0,

            @fple_map.get_textureset_id(texture_id),

            @fple_map.get_textureset_width(texture_id), 0, 8])

          end

        end

      end

      i -= 1

    end

    return surfaces_temp

  end

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

  # * Recherche des surfaces visibles en déplacement latéral

  # param surfaces_temp : Array>

  # param x : Integer

  # param y : Integer

  # param dxy : Integer

  # param oy : Integer

  # param ox : Integer

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

  def add_surfaces_strafe(surfaces_temp, x, y, dxy, ox, oy)

    if @fple_map.get_data(x, y)[0] > 0 # wall tile

      if @fple_map.get_data(x + ox, y + oy)[0] == 0 # --> visible !

        texture_id = @fple_map.get_data(x, y)[

        FPLE::MAP_SIDES[@current_dir - 1 >> 1]]

        if @fple_map.is_texture_id_valid?(texture_id)

          surfaces_temp.push([texture_id, dxy - 1, dxy, 1, 0, 0,

          @fple_map.get_textureset_id(texture_id),

          @fple_map.get_textureset_width(texture_id), 0, 8])

        end

      end

    else

      # side wall (Right)

      if @fple_map.get_data(x + oy, y - ox)[0] > 0 # side wall tile

        texture_id = @fple_map.get_data(x + oy, y - ox)[

        FPLE::MAP_SIDES_RIGHT[@current_dir - 1 >> 1]]

        if @fple_map.is_texture_id_valid?(texture_id)

          surfaces_temp.push([texture_id, dxy, dxy + 1, 0, 0, 0,

          @fple_map.get_textureset_id(texture_id),

          @fple_map.get_textureset_width(texture_id), 0, 8])

        end

      end

    end

end

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

# ** Game_Character

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

class Game_Character < Game_CharacterBase

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias moving_fple_game_character? moving?

    @already_aliased_fple = true

  end

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

  # * Determine if Moving

  # return Boolean

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

  def moving?

    if $game_system.fple

      return $game_temp.movement || moving_fple_game_character?

    else

      return moving_fple_game_character?

    end

  end

end

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

# ** Game_Player

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

class Game_Player < Game_Character

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

  # * Aliased methods (F12 compatibility) - mod [1.1]

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

  unless @already_aliased_fple

    alias move_straight_fple_game_player move_straight

    alias move_diagonal_fple_game_player move_diagonal

    alias turn_right_90_fple_game_player turn_right_90

    alias turn_left_90_fple_game_player turn_left_90

    alias move_by_input_fple_game_player move_by_input

    alias update_nonmoving_fple_game_player update_nonmoving

    @already_aliased_fple = true

  end

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

  # * Initialize Public Member Variables

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

  def init_public_members

    super

    @direction = 8

  end

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

  # * Move Straight

  # param d : Integer

  # param turn_ok : Boolean

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

  def move_straight(d, turn_ok = true)

    if $game_system.fple

      case d

      when 2

        case $game_player.direction

        when 2

          go_forward

        when 4

          strafe_left

        when 6

          strafe_right

        when 8

          go_backward

        end

      when 4

        case $game_player.direction

        when 2

          strafe_right

        when 4

          go_forward

        when 6

          go_backward

        when 8

          strafe_left

        end

      when 6

        case $game_player.direction

        when 2

          strafe_left

        when 4

          go_backward

        when 6

          go_forward

        when 8

          strafe_right

        end

      when 8

        case $game_player.direction

        when 2

          go_backward

        when 4

          strafe_right

        when 6

          strafe_left

        when 8

          go_forward

        end

      end

    else

      move_straight_fple_game_player(d, turn_ok)

    end

  end

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

  # * Move Diagonally

  # param horz : Integer

  # param vert : Integer

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

  def move_diagonal(horz, vert)

    unless $game_system.fple

      move_diagonal_fple_game_player(horz, vert)

    end

  end

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

  # * Jump

  # param x_plus : Integer

  # param y_plus : Integer

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

  def jump(x_plus, y_plus)

    unless $game_system.fple

      super(x_plus, y_plus) # [1.1]

    end

  end

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

  # * Turn 90° Right

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

  def turn_right_90

    turn_right_90_fple_game_player

    if $game_system.fple && !@direction_fix

      $game_temp.movement_init = false

      $game_temp.movement = true

      $game_temp.movement_dir = 9

    end

  end

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

  # * Turn 90° Left

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

  def turn_left_90

    turn_left_90_fple_game_player

    if $game_system.fple && !@direction_fix

      $game_temp.movement_init = false

      $game_temp.movement = true

      $game_temp.movement_dir = 10

    end

  end

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

  # * Go Forward

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

  def go_forward

    mvt_data = FPLE::PLAYER_MOVE_FORWARD[(@direction >> 1) - 1]

    if passable?(@x, @y, @direction)

      @x += mvt_data[0]

      @y += mvt_data[1]

      increase_steps

      $game_temp.movement = true

      $game_temp.movement_dir = 8

    else

      check_event_trigger_touch(@x + mvt_data[0], @y + mvt_data[1])

    end

  end

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

  # * Go Backward

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

  def go_backward

    target_dir = 10 - @direction

    mvt_data = FPLE::PLAYER_MOVE_FORWARD[(target_dir >> 1) - 1]

    if passable?(@x, @y, target_dir)

      @x += mvt_data[0]

      @y += mvt_data[1]

      increase_steps

      $game_temp.movement_init = false

      $game_temp.movement = true

      $game_temp.movement_dir = 2

    else

      check_event_trigger_touch(@x + mvt_data[0], @y + mvt_data[1])

    end

  end

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

  # * Strafe Left

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

  def strafe_left

    target_dir = FPLE::TURN_LEFT[(@direction >> 1) - 1]

    mvt_data = FPLE::PLAYER_MOVE_FORWARD[(target_dir >> 1) - 1]

    if passable?(@x, @y, target_dir)

      @x += mvt_data[0]

      @y += mvt_data[1]

      increase_steps

      $game_temp.movement_init = false

      $game_temp.movement = true

      $game_temp.movement_dir = 4

    else

      check_event_trigger_touch(@x + mvt_data[0], @y + mvt_data[1])

    end

  end

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

  # * Strafe Right

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

  def strafe_right

    target_dir = 10 - FPLE::TURN_LEFT[(@direction >> 1) - 1]

    mvt_data = FPLE::PLAYER_MOVE_FORWARD[(target_dir >> 1) - 1]

    if passable?(@x, @y, target_dir)

      @x += mvt_data[0]

      @y += mvt_data[1]

      increase_steps

      $game_temp.movement_init = false

      $game_temp.movement = true

      $game_temp.movement_dir = 6

    else

      check_event_trigger_touch(@x + mvt_data[0], @y + mvt_data[1])

    end

  end

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

  # * Processing of Movement via input from the Directional Buttons

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

  def move_by_input

    if $game_system.fple

      if !movable? || $game_map.interpreter.running? then return end

      if Input.press?(:L)

        strafe_left

      elsif Input.press?(:R)

        strafe_right

      else

        case Input.dir4

        when 2; go_backward

        when 4; turn_left_90

        when 6; turn_right_90

        when 8; go_forward

        end

      end

    else

      move_by_input_fple_game_player

    end

  end

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

  # * Processing when not moving

  # param last_moving : Boolean

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

  def update_nonmoving(last_moving)

    if $game_map.interpreter.running? then return end

    update_nonmoving_fple_game_player(last_moving)

    if last_moving then $game_temp.last_moving = false end

  end

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

  # * Move speed in FPLE mode

  # return Integer

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

  def move_speed_fple

    return FPLE::PLAYER_MOVE_SPEED[real_move_speed]

  end

end

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

# ** Game_Event

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

class Game_Event < Game_Character

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias refresh_fple_game_character refresh

    @already_aliased_fple = true

  end

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

  # * Public Instance Variables

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

  attr_reader :fple_type # Integer 0:face the player

                         #         1:horizontal wall in the RMXP editor view

                         #         2:vertical wall in the RMXP editor view

                         #         3:4-sided box (NEW)

                         #         4:6-sided box (NEW)

  attr_reader :fple_v_align # Integer - Vertical align {0:up, 1:middle, 2:down}

  attr_reader :fple_d_align # Integer - Depth align {0:front/left, 1:middle, 2:back/right}

  attr_reader :fple_stretch # Integer (0/1)

  attr_reader :fple_fit # Integer (0/1)

  attr_reader :fple_zoom # Integer (1024 <=> zoom = 1.0)

  attr_reader :fple_one_side # Boolean (0/1)

  attr_reader :fple_two_side # Boolean - NEW: indicates 6-sided box mode

  attr_reader :fple_four_side # Boolean - NEW: indicates 4-sided box mode

  attr_reader :fple_six_side # Boolean - NEW: indicates 6-sided box mode

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

  # * Scan the event's commands list

  # param page : RPG::Event::Page

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

  def check_commands(page)

    @fple_type = 0

    @fple_v_align = 1

    @fple_d_align = 1

    @fple_stretch = 0

    @fple_fit = 0

    @fple_zoom = 1024

    @fple_one_side = false # [1.5]

    @fple_two_side = false # NEW

    @fple_four_side = false # NEW

    @fple_six_side = false # NEW

    command_list = page.list

    (0..command_list.length - 2).each {|k|

      command = command_list[k]

      if command.code == 108

        comments = command.parameters[0]

        if comments[/Type/]

          @fple_type = comments[/\d+/].to_i

          if @fple_type < 0 || @fple_type > 2 then @fple_type = 0 end

        end

        if comments[/V-Align/]

          @fple_v_align = comments[/\d+/].to_i

          if @fple_v_align < 0 || @fple_v_align > 2 then @fple_v_align = 1 end

        end

        if comments[/D-Align/]

          @fple_d_align = comments[/\d+/].to_i

          if @fple_d_align < 0 || @fple_d_align > 2 then @fple_d_align = 1 end

        end

        if comments[/Stretch/]

          @fple_stretch = 1

        end

        if comments[/Fit/]

          @fple_fit = 1

        end

        if comments[/Zoom/]

          @fple_zoom = (comments[/\d+\.\d+/].to_f * 1024).round

        end

        if comments[/1-Side/] # [1.5]

          @fple_one_side = true

        end

        if comments[/2-Side/] # NEW

          @fple_four_side = true

        end

        if comments[/4-Side/] # NEW

          @fple_four_side = true

        end

        if comments[/6-Side/] # NEW

          @fple_six_side = true

        end

      end

    }

    if @fple_type == 0 then @fple_d_align = 1 end

    if @fple_stretch == 1 then @fple_v_align = 1 end

    if @fple_two_side

    elsif @fple_four_side

      @fple_type = 3 # Special type for 4-sided boxes

      @fple_d_align = 1 # Center alignment makes most sense

    elsif @fple_six_side

      @fple_type = 4 # Special type for 6-sided boxes

      @fple_d_align = 1 # Center alignment makes most sense

    end

  end

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

  # * Refresh

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

  def refresh

    refresh_fple_game_character

    if @page then check_commands(@page) end

  end

end

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

# ** FPLE::Map_Data

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

module FPLE

  class Map_Data

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

    # * Public Instance Variables

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

    attr_accessor :data, :tileset_name, :map_name

    attr_accessor :used_tiles_map, :textureset_data, :subsets_mapping

    attr_reader :map_id, :width, :height

  end

end

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

# ** FPLE::Map

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

module FPLE

  class Map

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

    # * Public Instance Variables

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

    attr_accessor :data, :tileset_name, :map_name

    attr_reader :map_id, :width, :height

    attr_accessor :textureset

    attr_accessor :texturesets

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

    # * Initialisation

    # param width : integer (largeur de la carte, donc égal à $game_map.width)

    # param height : integer (hauteur de la carte, donc égal à $game_map.height)

    # param name : String (nom du fichier de la carte FPLE)

    # param tileset_name : String (nom du tileset utilisé)

    # param map_data : Array[width * height]>

    # param subsets_mapping : Hash {texture_id=>subset_name}

    # param textureset_data : Array données de création du textureset

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

    def initialize(width, height, name, tileset_name, map_data = nil,

      subsets_mapping = nil, textureset_data = nil)

      @width = width

      @height = height

      self.map_name = name

      self.data = Array.new(width * height)

      data.each_index {|index| data[index] = map_data[index]}

      self.tileset_name = tileset_name

      @subsets_mapping = subsets_mapping

      create_textureset_from_data(textureset_data)

    end

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

    # * Retourne les données d'un tile par ses coordonées

    # param x : integer ([0, width[)

    # param y : integer ([0, height[)

    # return Array[10] (map_Data)

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

    def get_data(x, y)

      ret = data[get_index(x, y)]

      ret = [-1] unless ret

      return ret

    end

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

    # * Retourne l'index d'un tile par ses coordonées

    # param x : integer ([0, width[)

    # param y : integer ([0, height[)

    # return integer (> 0)

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

    def get_index(x, y)

      return x + y * width

    end

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

    # * Retourne l'abscisse d'un tile par son index

    # return integer ([0, width[)

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

    def get_x(index)

      return index - width * (index / width)

    end

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

    # * Retourne l'ordonnée d'un tile par son index

    # return integer ([0, height[)

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

    def get_y(index)

      return index / width

    end

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

    # * Création du textureset

    # param textureset_data : Array données de création du textureset

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

        def get_texture_lazy(texture_id)

      @texture_cache ||= {}

      return @texture_cache[texture_id] if @texture_cache.has_key?(texture_id)

      # Only load texture if it will be used

      if is_texture_id_valid?(texture_id)

        @texture_cache[texture_id] = load_texture(texture_id)

      else

        @texture_cache[texture_id] = nil

      end

      return @texture_cache[texture_id]

    end

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

    def create_textureset_from_data(textureset_data)

      rect = Rect.new(0, 0, 32, 32)

      textureset_height = 1 + (textureset_data.size >> 3) << 5

      self.textureset = Bitmap.new(256, textureset_height)

      src = Cache.tileset(tileset_name)

      textureset_data.each_index {|texture_id|

        t_dat = textureset_data[texture_id]

        if t_dat

          x_trg = texture_id - (texture_id >> 3 << 3) << 5

          y_trg = texture_id >> 3 << 5

          rect.x = t_dat[0]

          rect.y = t_dat[1]

          if t_dat[0] == 0 && t_dat[1] == 0

            @texture_id_nil = texture_id

          end

          textureset.blt(x_trg, y_trg, src, rect)

        end

      }

      @texturesets = [textureset]

      @texturesets_widths = [8]

      @texturesets_mapping_ids = {}

      subsets_names_list = []

      if @subsets_mapping

        @subsets_mapping.each {|texture_id, subset_name|

          if subsets_names_list.include?(subset_name)

            @texturesets_mapping_ids[texture_id] =

            subsets_names_list.index(subset_name) + 1

          else

            subsets_names_list << subset_name

            subset = Cache.tileset(subset_name)

            texturesets << subset

            for k in 5..9

              if subset.width >> k == 1

                @texturesets_widths << k

                break

              end

            end

            @texturesets_mapping_ids[texture_id] = subsets_names_list.size

          end

        }

      end

    end

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

    # * Retourne l'index du textureset pour une texture

    # param textureset_data : Integer

    # return Integer

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

    def get_textureset_id(texture_id)

      if @texturesets_mapping_ids.has_key?(texture_id)

        return @texturesets_mapping_ids[texture_id]

      else

        return 0

      end

    end

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

    # * Retourne la largeur du textureset pour une texture

    # param textureset_data : Integer

    # return Integer

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

    def get_textureset_width(texture_id)

      return @texturesets_widths[get_textureset_id(texture_id)]

    end

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

    # * Dispose

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

    def dispose

      if textureset then textureset.dispose end

    end

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

    # * Is texture valid

    # param texture_id : Integer

    # return Boolean

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

    def is_texture_id_valid?(texture_id)

      return texture_id && texture_id != @texture_id_nil

    end

  end

end

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

# ** Spriteset_Weather

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

class Spriteset_Weather

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

  # * Modification of sprites coordinates when moving forward and backward

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

  def update_fple

    @sprites.each {|sprite|

      if $game_temp.movement_dir == 8

        sprite.x += (sprite.x + @ox - 272) / 8

        sprite.y += (sprite.y + @oy - 208) / 8

        sprite.opacity += 8

      elsif $game_temp.movement_dir == 2

        sprite.x -= (sprite.x + @ox - 272) / 8

        sprite.y -= (sprite.y + @oy - 139) / 8

        sprite.opacity -= 8

      end

    }

  end

end

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

# ** FPLE::Spriteset_Map

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

module FPLE

  class Spriteset_Map < ::Spriteset_Map

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

    # * Public Instance Variables

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

    attr_reader :character_surfaces # Array

    attr_reader :viewport1 # Viewport

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

    # * Create Tilemap

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

    def create_tilemap

      # do nothing

    end

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

    # * Create Character Surfaces

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

    def create_characters

      @character_surfaces = []

      $game_map.events.values.each {|event|

        character_surfaces << FPLE::Surface_Character.new(self, event)

      }

      @map_id = $game_map.map_id

      initialize_fple_rendering

    end

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

    # * Create Airship Shadow Sprite

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

    def create_shadow

      # do nothing

    end

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

    # * Initialize FPLE rendering

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

    def initialize_fple_rendering

      FPLE.initialize_fple(self, @viewport1)

    end

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

    # * Dispose

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

    def dispose

      dispose_fple_rendering

      super

    end

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

    # * Dispose of FPLE rendering

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

    def dispose_fple_rendering

      FPLE.dispose

    end

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

    # * Free Tilemap

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

    def dispose_tilemap

      # do nothing

    end

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

    # * Dispose of Character Surfaces

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

    def dispose_characters

      @character_surfaces.each {|surface| surface.dispose}

    end

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

    # * Free Airship Shadow Sprite

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

    def dispose_shadow

      # do nothing

    end

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

    # * Update Tileset

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

    def update_tileset

      # do nothing

    end

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

    # * Update Tilemap

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

    def update_tilemap

      # do nothing

    end

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

    # * Update Parallax

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

    def update_parallax

      super

      if @parallax.bitmap

        @parallax.ox += (@parallax.bitmap.width * FPLE.angle) / 90

      end

    end

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

    # * Update Character Sprite

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

    def update_characters

      unless @map_id == $game_map.map_id then refresh_characters end

      character_surfaces.each {|surface| surface.update}

      update_fple_rendering

    end

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

    # * Update FPLE Rendering

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

    def update_fple_rendering

      FPLE.update

    end

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

    # * Update Airship Shadow Sprite

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

    def update_shadow

      # do nothing

    end

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

    # * Update Weather

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

    def update_weather

      @weather.type = $game_map.screen.weather_type

      @weather.power = $game_map.screen.weather_power

      @weather.ox = $game_map.display_x * 32 +

      (Graphics.width * FPLE.angle) / 90 +

      (Graphics.width * FPLE.offset_x >> 5)

      @weather.oy = $game_map.display_y * 32

      @weather.update

      if FPLE.offset_y > 0 then @weather.update_fple end

    end

  end

end

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

# ** FPLE::Surface_Character

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

module FPLE

  class Surface_Character

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

    # * Public Instance Variables

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

    attr_accessor :character # Game_Event

    attr_accessor :bitmap_set # Bitmap

    attr_accessor :bitmap # Bitmap

    attr_accessor :visible # Boolean

    attr_accessor :opacity # Integer

    attr_accessor :blend_type # Integer

    attr_accessor :dx # Integer

    attr_accessor :dy # Integer

    attr_accessor :displayed # Boolean

    attr_reader :spriteset # FPLE::Spriteset_Map

    attr_reader :type # Integer

    attr_reader :v_align # Integer

    attr_reader :d_align # Integer

    attr_reader :fit # Integer (0/1)

    attr_reader :zoom # Integer (1024 <=> zoom = 1.0)

    attr_reader :mirror # Integer (0/1) # [1.5]

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

    # * Object Initialization

    # param spriteset : FPLE::Spriteset_Map

    # param character : Game_Event

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

    def initialize(spriteset, character = nil)

      @spriteset = spriteset

      self.character = character

      self.displayed = false

      @need_refresh = false

      @dx_old = 0

      @dy_old = 0

      @sx_old = -1

      @sy_old = -1

      @visible_old

      @opacity_old

      @blend_type_old

      @sprite_temp = nil

      @balloon_duration = 0

      if character

        @fit = character.fple_fit

        @zoom = character.fple_zoom

      else

        @fit = 0

        @zoom = 1024

      end

      @mirror = 0 # [1.5]

      update

    end

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

    # * Dispose

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

    def dispose

      if @sprite_temp

        @sprite_temp.dispose

        @sprite_temp = nil

      end

      if bitmap_set then self.bitmap_set.dispose end

      if bitmap then self.bitmap.dispose end

    end

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

    # * Get tile set image that includes the designated tile

    # param tile_id : Integer

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

    def tileset_bitmap(tile_id)

      set_number = tile_id / 256

      return Cache.system("TileB") if set_number == 0

      return Cache.system("TileC") if set_number == 1

      return Cache.system("TileD") if set_number == 2

      return Cache.system("TileE") if set_number == 3

      return nil

    end

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

    # * Frame Update

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

    def update

      update_bitmap

      update_src_rect

      update_position

      update_other

      update_balloon

      setup_new_effect

      if need_refresh? then force_render end

    end

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

    # * Update Transfer Origin Bitmap

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

    def update_bitmap

      if graphic_changed?

        @tile_id = @character.tile_id

        @character_name = @character.character_name

        @character_index = @character.character_index

        if @tile_id > 0

          set_tile_bitmap

        else

          set_character_bitmap

        end

        @need_refresh = true

      end

    end

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

    # * Determine if Graphic Changed

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

    def graphic_changed?

      @tile_id != character.tile_id ||

      @character_name != character.character_name ||

      @character_index != character.character_index

    end

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

    # * Set Tile Bitmap

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

    def set_tile_bitmap

      @sx = (@tile_id / 128 % 2 * 8 + @tile_id % 8) * 32;

      @sy = @tile_id % 256 / 8 % 16 * 32;

      self.bitmap_set = tileset_bitmap(@tile_id)

      @cw = 32

      @ch = 32

      self.bitmap = Bitmap.new(@cw, @ch)

    end

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

    # * Set Character Bitmap

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

    def set_character_bitmap

      self.bitmap_set = Cache.character(@character_name)

      sign = @character_name[/^[\!\$]./]

      if sign && sign.include?('$')

        @cw = bitmap_set.width / 3

        @ch = bitmap_set.height / 4

      else

        @cw = bitmap_set.width / 12

        @ch = bitmap_set.height / 8

      end

      self.bitmap = Bitmap.new(@cw, @ch)

    end

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

    # * Update Transfer Origin Rectangle

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

    def update_src_rect

      if @tile_id == 0

        index = character.character_index

        pattern = character.pattern < 3 ? character.pattern : 1

        @sx = (index % 4 * 3 + pattern) * @cw

        unless character.direction_fix

          case $game_player.direction

          when 2

            direction = 10 - character.direction

          when 4

            direction = 10 - FPLE::TURN_LEFT[(character.direction >> 1) - 1]

          when 6

            direction = FPLE::TURN_LEFT[(character.direction >> 1) - 1]

          when 8

            direction = character.direction

          end

        else

          direction = character.direction

        end

        @sy = ((index >> 2 << 2) + (direction - 2 >> 1)) * @ch

      end

      if @sx_old != @sx || @sy_old != @sy

        return if @sx == @sx_old && @sy == @sy_old && !@bitmap_dirty

        self.bitmap.clear

        self.bitmap.blt(0, 0, bitmap_set, Rect.new(@sx, @sy, @cw, @ch))

         @sx_old = @sx

    @sy_old = @sy

    @bitmap_dirty = false

      end

    end

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

    # * Update Position

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

    def update_position

      self.dx = (128 * character.real_x).to_i

      self.dy = (128 * character.real_y).to_i

    end

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

    # * Update Other

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

    def update_other

      self.opacity = character.opacity

      self.blend_type = character.blend_type

      self.visible = !character.transparent

    end

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

    # * Set New Effect

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

    def setup_new_effect

      if character.animation_id > 0

        if displayed

          unless @sprite_temp

            # create a temporary sprite to launch animation

            @sprite_temp = Sprite_Base.new(spriteset.viewport1)

          end

          coordinates = find_coordinates

          if coordinates

            @sprite_temp.x = coordinates[0]

            @sprite_temp.y = coordinates[1]

            animation = $data_animations[character.animation_id]

            @sprite_temp.start_animation(animation)

          else

            @sprite_temp.dispose

            @sprite_temp = nil

          end

        end

        character.animation_id = 0

      end

      if @sprite_temp

        @sprite_temp.update

        unless @sprite_temp.animation?

          @sprite_temp.dispose

          @sprite_temp = nil

        end

      end

      if !@balloon_sprite && character.balloon_id != 0

        @balloon_id = character.balloon_id

        start_balloon

      end

    end

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

    # * Determine if Changed

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

    def need_refresh?

      @need_refresh || @dx_old != dx || @dy_old != dy ||

      @sx_old != @sx || @sy_old != @sy ||

      @visible_old != visible || @opacity_old != opacity ||

      @blend_type_old != blend_type

    end

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

    # * Force Render

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

    def force_render

      if displayed then $game_temp.force_render = true end

      @dx_old = dx

      @dy_old = dy

      @sx_old = @sx

      @sy_old = @sy

      @visible_old = visible

      @opacity_old = opacity

      @blend_type_old = blend_type

      @need_refresh = false

    end

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

    # * Refresh FPLE attributes sepending on the relative frame of reference

    # param direction : Integer

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

def set_relative_attributes(direction)

      # For 4-sided and 6-sided surfaces, we don't need to change attributes

      # since all sides are rendered automatically

      if character.fple_four_side

        @type = 3 # Special identifier for 4-sided

        @d_align = character.fple_d_align

        @v_align = character.fple_v_align

        @mirror = 0 # Could add logic for different mirror states per side if needed

        return

      elsif character.fple_six_side

        @type = 4 # Special identifier for 6-sided

        @d_align = character.fple_d_align

        @v_align = character.fple_v_align

        @mirror = 0 # Could add logic for different mirror states per side if needed

        return

      end

      # Original logic for single surfaces

      case direction

      when 2

        @type = character.fple_type

        @d_align = 2 - character.fple_d_align

        if character.fple_one_side

          @mirror = 1

          if type == 2 && ($game_player.x << 7) - dx <= 0

            @mirror = 0

          end

        end

      when 4

        if character.fple_type > 0

          @type = 3 - character.fple_type

        else

          @type = 0

        end

        if character.fple_type < 2

          @d_align = character.fple_d_align

        elsif character.fple_type == 2

          @d_align = 2 - character.fple_d_align

        end

        if character.fple_one_side

          @mirror = 1

          if type == 2 && ($game_player.y << 7) - dy > 0

            @mirror = 0

          end

        end

      when 6

        if character.fple_type > 0

          @type = 3 - character.fple_type

        else

          @type = 0

        end

        if character.fple_type < 2

          @d_align = 2 - character.fple_d_align

        elsif character.fple_type == 2

          @d_align = character.fple_d_align

        end

        if character.fple_one_side

          @mirror = 0

          if type == 2 && ($game_player.y << 7) - dy < 0

            @mirror = 1

          end

        end

      when 8

        @type = character.fple_type

        @d_align = character.fple_d_align

        if character.fple_one_side

          @mirror = 0

          if type == 2 && ($game_player.x << 7) - dx >= 0

            @mirror = 1

          end

        end

      end

      @v_align = character.fple_v_align

    end

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

    # * Calculate screen coordinates to display animations

    # return Array[2]

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

  def find_coordinates

      direction = $game_player.direction

      case direction

      when 2

        y = dy - ($game_player.y << 7)

        x = ($game_player.x << 7) - dx

      when 4

        y = ($game_player.x << 7) - dx

        x = ($game_player.y << 7) - dy

      when 6

        y = dx - ($game_player.x << 7)

        x = dy - ($game_player.y << 7)

      when 8

        y = ($game_player.y << 7) - dy

        x = dx - ($game_player.x << 7)

      end

      if y == 0 then return nil end

      offset_x = 0

      offset_y = 0

      if character.fple_v_align != 1

        x1_proj = 272 + (272 * x - (136 << 7)) / y

        x2_proj = 272 + (272 * x + (136 << 7)) / y

        offset_x = x2_proj - x1_proj >> 1

        offset_y = offset_x

        if bitmap

          offset_x -= (bitmap.width >> 1)

          offset_y -= (bitmap.height >> 1)

        end

      end

      x_proj = 272 + (272 * x) / y

      y_proj = ((544 * y) - (272 << 7)) / (y << 1)

      if character.fple_v_align == 0

        y_proj -= offset_y

      elsif character.fple_v_align == 2

        y_proj += offset_y

      end

      return [x_proj, y_proj]

    end

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

    # * Start Balloon Icon Display

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

    def start_balloon

      dispose_balloon

      @balloon_duration = 8 * balloon_speed + balloon_wait

      @balloon_sprite = ::Sprite.new(spriteset.viewport1)

      @balloon_sprite.bitmap = Cache.system("Balloon")

      @balloon_sprite.ox = -16

      @balloon_sprite.oy = +128

      update_balloon

    end

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

    # * Dispose of Balloon Icon

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

    def dispose_balloon

      if @balloon_sprite

        @balloon_sprite.dispose

        @balloon_sprite = nil

      end

    end

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

    # * Update Balloon Icon

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

    def update_balloon

      if @balloon_duration > 0

        @balloon_duration -= 1

        if @balloon_duration > 0

          coordinates = find_coordinates

          if coordinates

            @balloon_sprite.x = coordinates[0]

            @balloon_sprite.y = coordinates[1]

            @balloon_sprite.z = 9999

            sx = balloon_frame_index * 32

            sy = (@balloon_id - 1) * 32

            @balloon_sprite.src_rect.set(sx, sy, 32, 32)

          else

            end_balloon

          end

        else

          end_balloon

        end

      end

    end

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

    # * End Balloon Icon

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

    def end_balloon

      dispose_balloon

      character.balloon_id = 0

    end

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

    # * Balloon Icon Display Speed

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

    def balloon_speed

      return 8

    end

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

    # * Wait Time for Last Frame of Balloon

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

    def balloon_wait

      return 12

    end

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

    # * Frame Number of Balloon Icon

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

    def balloon_frame_index

      return 7 - [(@balloon_duration - balloon_wait) / balloon_speed, 0].max

    end

  end

end

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

# ** Scene_Map

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

class Scene_Map < Scene_Base

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

  # * Aliased methods (F12 compatibility)

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

  unless @already_aliased_fple

    alias create_spriteset_fple create_spriteset

    alias perform_transfer_fple perform_transfer

    alias post_transfer_fple post_transfer

    @already_aliased_fple = true

  end

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

  # * Create Sprite Set

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

  def create_spriteset

    if $game_system.fple

      @spriteset = FPLE::Spriteset_Map.new

    else

      create_spriteset_fple

    end

  end

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

  # * Player Transfer Processing

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

  def perform_transfer

    @exec_transfer = $game_player.transfer?

    @fple_old = $game_system.fple

    perform_transfer_fple

  end

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

  # * Post Processing for Transferring Player

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

  def post_transfer

    if @exec_transfer && @fple_old != $game_system.fple

      @spriteset.dispose

      create_spriteset

    end

    if $game_system.fple

      $game_temp.force_render = true

    end

    post_transfer_fple

  end

end

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

# ** FPLE Background Picture Addon - Enhanced

#v.1.5 old, now upgraded to v.1.8 using Claude.AI by 5Brainplay.

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

# This addon creates a background picture that renders behind all FPLE surfaces

# but in front of the engine's default background to prevent color bleeding.

# The background now positions itself at VIEW_DISTANCE + 1 for proper depth.

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

module FPLE

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

  # * Background Picture Configuration

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

  BACKGROUND_ENABLED = false      # Enable/disable background picture

  BACKGROUND_COLOR = Color.new(115, 190, 215, 255)  # Default color (R,G,B,A)

  BACKGROUND_PICTURE_FILE = nil  # Optional: use "filename" for custom image

  BACKGROUND_Z_DEPTH = -999    # Z-depth (negative = behind everything)

end

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

# ** FPLE Core - Modified

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

module FPLE

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

  # * Aliased initialization method

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

  class << self

    unless @background_addon_aliased

      alias initialize_fple_background initialize_fple

      @background_addon_aliased = true

    end

  end

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

  # * Initialize with background

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

  def self.initialize_fple(spriteset, viewport)

    initialize_fple_background(spriteset, viewport)

    if BACKGROUND_ENABLED

      create_background_picture(viewport)

    end

  end

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

  # * Create background picture with view distance integration

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

  def self.create_background_picture(viewport)

    @background_sprite = Sprite.new(viewport)

    @background_sprite.z = BACKGROUND_Z_DEPTH

    if BACKGROUND_PICTURE_FILE && FileTest.exist?("Graphics/Pictures/#{BACKGROUND_PICTURE_FILE}.png")

      # Use custom image file

      @background_sprite.bitmap = Cache.picture(BACKGROUND_PICTURE_FILE)

    else

      # Create solid color background

      @background_sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)

      @background_sprite.bitmap.fill_rect(0, 0, Graphics.width, Graphics.height, BACKGROUND_COLOR)

    end

    # Position behind everything but visible

    @background_sprite.x = 0

    @background_sprite.y = 0

    # Add background surface to the surfaces array for proper depth rendering

    create_background_surface

  end

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

  # * Create background surface at VIEW_DISTANCE + 1

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

  def self.create_background_surface

    # Calculate the distance to render the background at (VIEW_DISTANCE + 1)

    background_distance = ($game_system.fple_view_distance + 1) << 7

    # Create a background surface that will be processed by the 3D engine

    @background_surface = [

      0,                          # texture_id (0 = no texture, use solid color)

      background_distance,        # dy (depth distance)

      0,                          # dx (horizontal offset)

      6,                          # type (6 = background plane, custom type)

      0,                          # secondary texture

      0,                          # z-order placeholder

      0,                          # textureset_id

      8,                          # textureset_width

      BACKGROUND_COLOR.red,       # red component

      BACKGROUND_COLOR.green,     # green component

      BACKGROUND_COLOR.blue,      # blue component

      BACKGROUND_COLOR.alpha      # alpha component

    ]

  end

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

  # * Add background surface to game map surfaces

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

  def self.add_background_to_surfaces

    return unless BACKGROUND_ENABLED && @background_surface

    # Calculate proper z-depth for background

    distance = ($game_system.fple_view_distance) << 1

    @background_surface[5] = distance << 5  # Set z-order

    # Add background surface to the main surfaces array if not already present

    unless $game_map.surfaces.any? { |surface| surface[3] == 6 }

      $game_map.surfaces.push(@background_surface.dup)

    end

  end

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

  # * Aliased dispose method

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

  class << self

    unless @dispose_background_aliased

      alias dispose_background dispose

      @dispose_background_aliased = true

    end

  end

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

  # * Dispose with background cleanup

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

  def self.dispose

    dispose_background

    if @background_sprite

      @background_sprite.dispose

      @background_sprite = nil

    end

    @background_surface = nil

  end

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

  # * Update background (called during movement/rotation)

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

  def self.update_background

    return unless @background_surface && BACKGROUND_ENABLED

    # Update the background distance based on current view distance

    background_distance = ($game_system.fple_view_distance) << 7

    @background_surface[1] = background_distance

    # Update z-order

    distance = ($game_system.fple_view_distance) << 1

    @background_surface[5] = distance << 5

    # Add parallax effects if desired

    if @angle != 0

      # Slight horizontal shift based on rotation

      @background_surface[2] = (@angle * 2)  # Adjust multiplier as needed

    else

      @background_surface[2] = 0

    end

    # Adjust for movement offsets if desired (subtle parallax)

    # @background_surface[2] += @offset_x / 8

  end

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

  # * Aliased update method

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

  class << self

    unless @update_background_aliased

      alias update_fple_background update

      @update_background_aliased = true

    end

  end

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

  # * Update with background

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

  def self.update

    update_fple_background

    if BACKGROUND_ENABLED

      update_background

      add_background_to_surfaces

    end

  end

end

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

# ** Game_Map - Background Integration

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

class Game_Map

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

  # * Aliased refresh_surfaces method

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

  unless @background_surfaces_aliased

    alias refresh_surfaces_background refresh_surfaces

    @background_surfaces_aliased = true

  end

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

  # * Refresh surfaces with background integration

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

  def refresh_surfaces

    refresh_surfaces_background

      surfaces.sort! { |a, b| b[5] - a[5] } if surfaces.any? { |s| s[3] == 6 }

  end

end

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

# ** Game_Interpreter - Script Commands

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

class Game_Interpreter

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

  # * Change FPLE Background Color

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

  def change_fple_background_color(red, green, blue, alpha = 255)

    return unless $game_system.fple && FPLE::BACKGROUND_ENABLED

    # Update the background surface color

    if FPLE.instance_variable_get(:@background_surface)

      surface = FPLE.instance_variable_get(:@background_surface)

      surface[8] = red

      surface[9] = green

      surface[10] = blue

      surface[11] = alpha

    end

    # Also update the sprite for immediate visual feedback

    if FPLE.instance_variable_get(:@background_sprite)

      sprite = FPLE.instance_variable_get(:@background_sprite)

      color = Color.new(red, green, blue, alpha)

      sprite.bitmap.fill_rect(0, 0, Graphics.width, Graphics.height, color)

    end

    $game_temp.force_render = true

  end

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

  # * Change FPLE Background Picture

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

  def change_fple_background_picture(filename)

    return unless $game_system.fple && FPLE::BACKGROUND_ENABLED

    if FPLE.instance_variable_get(:@background_sprite)

      sprite = FPLE.instance_variable_get(:@background_sprite)

      sprite.bitmap.dispose if sprite.bitmap

      if filename && FileTest.exist?("Graphics/Pictures/#{filename}.png")

        sprite.bitmap = Cache.picture(filename)

        # When using a picture, set surface type to use texture instead of color

        if FPLE.instance_variable_get(:@background_surface)

          surface = FPLE.instance_variable_get(:@background_surface)

          surface[0] = 1  # Enable texture rendering

        end

      else

        # Fallback to solid color

        sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)

        sprite.bitmap.fill_rect(0, 0, Graphics.width, Graphics.height, FPLE::BACKGROUND_COLOR)

        # Reset to color mode

        if FPLE.instance_variable_get(:@background_surface)

          surface = FPLE.instance_variable_get(:@background_surface)

          surface[0] = 0  # Disable texture, use color

        end

      end

    end

    $game_temp.force_render = true

  end

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

  # * Toggle FPLE Background

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

  def toggle_fple_background(enabled)

    return unless $game_system.fple

    if FPLE.instance_variable_get(:@background_sprite)

      sprite = FPLE.instance_variable_get(:@background_sprite)

      sprite.visible = enabled

    end

    # Remove or add background surface based on enabled state

    if enabled

      FPLE.add_background_to_surfaces

    else

      $game_map.surfaces.reject! { |surface| surface[3] == 6 }

    end

    $game_temp.force_render = true

  end

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

  # * Update Background Distance (call when VIEW_DISTANCE changes)

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

  def update_background_distance

    return unless $game_system.fple && FPLE::BACKGROUND_ENABLED

    if FPLE.instance_variable_get(:@background_surface)

      FPLE.update_background

      $game_temp.force_render = true

    end

  end

end

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

# ** Game_Temp - Background Integration

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

class Game_Temp

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

  # * Aliased set_view method to update background distance

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

  unless @background_view_aliased

    alias set_view_background set_view

    @background_view_aliased = true

  end

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

  # * Set view distance with background update

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

  def set_view(distance)

    set_view_background(distance)

    # Update background distance when view distance changes

    if $game_system.fple && FPLE::BACKGROUND_ENABLED

      FPLE.update_background

    end

  end

end

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

# ** Usage Instructions

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

# Place this script below the main FPLE script but above Main.

#

# Configuration:

# - BACKGROUND_ENABLED: Set to true/false to enable/disable

# - BACKGROUND_COLOR: Set the RGB color (0-255 for each value)  

# - BACKGROUND_PICTURE_FILE: Optional - use a picture file instead of solid color

# - BACKGROUND_Z_DEPTH: Z-depth value (negative = behind surfaces)

#

# The background will automatically render at VIEW_DISTANCE + 1, providing

# a backdrop that appears behind all game surfaces but maintains proper depth.

#

# Script Commands (use in events):

# - change_fple_background_color(255, 0, 0)    # Change to red

# - change_fple_background_picture("sunset")   # Use Graphics/Pictures/sunset.png  

# - toggle_fple_background(false)              # Hide background

# - toggle_fple_background(true)               # Show background

# - update_background_distance                 # Refresh after VIEW_DISTANCE changes

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

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

# FPLE Ground Tile Swap Addon v1.1

# v.1.5 old, now upgraded to v.1.8 using Claude.AI by 5Brainplay.

# Author: Assistant

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

# This addon allows swapping ground tiles in FPLE maps during gameplay.

# Place this script below the main FPLE script but above "Main"

#

# Features:

# - Swap ground tiles at specific coordinates

# - Batch swap multiple tiles

# - Restore original tiles

# - Event-based tile swapping

# - Animated tile transitions (optional)

# - Region-based ground tile swapping

# - Animated region tiles

#

# Usage Examples:

# $game_map.swap_ground_tile(x, y, new_texture_id)

# $game_map.restore_ground_tile(x, y)

# $game_map.batch_swap_ground_tiles([[x1, y1, texture1], [x2, y2, texture2]])

# $game_map.swap_region_ground_tiles(region_id, texture_id)

#

# Event Commands:

# In event "Script..." command:

# swap_ground(x, y, texture_id)

# restore_ground(x, y)

# swap_region_ground(region_id, texture_id)

# animate_region_ground(region_id, base_texture_id)

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

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

# ** Game_Map - Ground Tile Swapping Extensions

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

class Game_Map

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

  # * Aliased methods

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

  unless @already_aliased_ground_swap

    alias initialize_ground_swap initialize

    alias setup_ground_swap setup

    @already_aliased_ground_swap = true

  end

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

  # * Public Instance Variables

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

  attr_accessor :original_ground_tiles  # Hash to store original tile data

  attr_accessor :swapped_ground_tiles   # Hash to track swapped tiles

  attr_accessor :animated_ground_tiles  # Hash to store animation data

  attr_accessor :ground_animation_timer # Integer for frame counting

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

  # * Object Initialization

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

  def initialize

    initialize_ground_swap

    @original_ground_tiles = {}

    @swapped_ground_tiles = {}

    @animated_ground_tiles = {}

    @ground_animation_timer = 0

  end

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

  # * Setup

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

  def setup(map_id)

    setup_ground_swap(map_id)

    @original_ground_tiles = {}

    @swapped_ground_tiles = {}

    @animated_ground_tiles = {}

    @ground_animation_timer = 0

  end

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

  # * Swap Ground Tile at Specific Coordinates

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate  

  # param new_texture_id : Integer - New ground texture ID

  # param animate : Boolean - Whether to animate the transition (optional)

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

  def swap_ground_tile(x, y, new_texture_id, animate = false)

    return unless is_fple? && @fple_map

    return unless valid_coordinates?(x, y)

    key = [x, y]

    # Store original tile data if not already stored

    unless @original_ground_tiles.has_key?(key)

      original_data = @fple_map.get_data(x, y).dup

      @original_ground_tiles[key] = original_data

    end

    # Use FPLE's proper method to change ground texture

    if @fple_map.respond_to?(:change_ground)

      @fple_map.change_ground(x, y, new_texture_id)

    elsif @fple_map.respond_to?(:set_ground_tile)

      @fple_map.set_ground_tile(x, y, new_texture_id)

    else

      # Fallback: try to modify the data structure directly

      current_data = @fple_map.get_data(x, y)

      if current_data && current_data.size > 1

        current_data[1] = new_texture_id

      else

        return false

      end

    end

    @swapped_ground_tiles[key] = new_texture_id

    # Remove from animated tiles when doing a simple swap

    @animated_ground_tiles.delete(key)

    # Trigger visual update

    if animate

      animate_tile_swap(x, y)

    else

      force_surface_refresh

    end

    return true

  end

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

  # * Create Animated Ground Tile (cycles through next 3 tiles)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate  

  # param base_texture_id : Integer - Base texture ID (will use this +1, +2, +3)

  # param frame_duration : Integer - Frames to wait between texture changes

  # param animate : Boolean - Whether to animate the initial transition

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

  def create_animated_ground_tile(x, y, base_texture_id, frame_duration = 30, animate = false)

    return unless is_fple? && @fple_map

    return unless valid_coordinates?(x, y)

    key = [x, y]

    # Store original tile data if not already stored

    unless @original_ground_tiles.has_key?(key)

      original_data = @fple_map.get_data(x, y).dup

      @original_ground_tiles[key] = original_data

    end

    # Setup animation data

    animation_data = {

      :frames => [base_texture_id, base_texture_id + 1, base_texture_id + 2],

      :current_frame => 0,

      :frame_duration => frame_duration,

      :frame_counter => 0

    }

    @animated_ground_tiles[key] = animation_data

    @swapped_ground_tiles[key] = base_texture_id

    # Set initial texture

    current_data = @fple_map.get_data(x, y)

    if current_data && current_data.size > 1

      current_data[1] = base_texture_id

      # Trigger visual update

      if animate

        animate_tile_swap(x, y)

      else

        force_surface_refresh

      end

      return true

    end

    return false

  end

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

  # * Restore Original Ground Tile

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

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

  def restore_ground_tile(x, y)

    return unless is_fple? && @fple_map

    return unless valid_coordinates?(x, y)

    key = [x, y]

    if @original_ground_tiles.has_key?(key)

      # Restore original data

      original_data = @original_ground_tiles[key]

      current_data = @fple_map.get_data(x, y)

      if current_data && original_data

        current_data[1] = original_data[1]  # Restore ground texture

        @swapped_ground_tiles.delete(key)

        @animated_ground_tiles.delete(key)  # Remove animation data

        force_surface_refresh

        return true

      end

    end

    return false

  end

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

  # * Batch Swap Multiple Ground Tiles

  # param tile_data : Array - [[x, y, texture_id], ...]

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

  def batch_swap_ground_tiles(tile_data)

    return unless is_fple? && tile_data.is_a?(Array)

    success_count = 0

    tile_data.each do |data|

      next unless data.is_a?(Array) && data.size >= 3

      x, y, texture_id = data[0], data[1], data[2]

      success_count += 1 if swap_ground_tile(x, y, texture_id, false)

    end

    force_surface_refresh if success_count > 0

    return success_count

  end

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

  # * Restore All Swapped Ground Tiles

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

  def restore_all_ground_tiles

    return unless is_fple? && @fple_map

    restored_count = 0

    @swapped_ground_tiles.keys.each do |key|

      x, y = key[0], key[1]

      restored_count += 1 if restore_ground_tile(x, y)

    end

    force_surface_refresh if restored_count > 0

    return restored_count

  end

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

  # * Swap All Ground Tiles in a Specific Region

  # param region_id : Integer - Region ID to target (1-63, or 0 for no region)

  # param new_texture_id : Integer - New ground texture ID for all tiles in region

  # param animate : Boolean - Whether to animate the transitions (optional)

  # param exclude_events : Boolean - Whether to skip tiles with events (optional)

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

  def swap_region_ground_tiles(region_id, new_texture_id, animate = false, exclude_events = false)

    return unless is_fple? && @fple_map

    return unless region_id >= 0 && region_id <= 63

    success_count = 0

    # Loop through all tiles in the map

    (0...width).each do |x|

      (0...height).each do |y|

        # Check if this tile has the target region ID

        if region_id(x, y) == region_id

          # Skip tiles with events if requested

          if exclude_events && events_xy(x, y).any?

            next

          end

          # Swap the ground tile

          if swap_ground_tile(x, y, new_texture_id, false)

            success_count += 1

          end

        end

      end

    end

    # Handle animation/refresh after all swaps are done

    if success_count > 0

      if animate

        # Create a region-wide flash effect

        $game_map.screen.start_flash(Color.new(255, 255, 255, 80), 15)

      end

      force_surface_refresh

    end

    return success_count

  end

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

  # * Create Animated Ground Tiles for Entire Region

  # param region_id : Integer - Region ID to target (1-63, or 0 for no region)

  # param base_texture_id : Integer - Base texture ID (will use this +1, +2)

  # param frame_duration : Integer - Frames to wait between texture changes

  # param animate : Boolean - Whether to animate the initial transition

  # param exclude_events : Boolean - Whether to skip tiles with events (optional)

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

  def animate_region_ground_tiles(region_id, base_texture_id, frame_duration = 30, animate = false, exclude_events = false)

    return unless is_fple? && @fple_map

    return unless region_id >= 0 && region_id <= 63

    success_count = 0

    # Loop through all tiles in the map

    (0...width).each do |x|

      (0...height).each do |y|

        # Check if this tile has the target region ID

        if region_id(x, y) == region_id

          # Skip tiles with events if requested

          if exclude_events && events_xy(x, y).any?

            next

          end

          # Create animated ground tile

          if create_animated_ground_tile(x, y, base_texture_id, frame_duration, false)

            success_count += 1

          end

        end

      end

    end

    # Handle animation/refresh after all animations are set up

    if success_count > 0

      if animate

        # Create a region-wide flash effect

        $game_map.screen.start_flash(Color.new(200, 255, 200, 100), 20)

      end

      force_surface_refresh

    end

    return success_count

  end

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

  # * Restore All Ground Tiles in a Specific Region

  # param region_id : Integer - Region ID to target (1-63, or 0 for no region)

  # param exclude_events : Boolean - Whether to skip tiles with events (optional)

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

  def restore_region_ground_tiles(region_id, exclude_events = false)

    return unless is_fple? && @fple_map

    return unless region_id >= 0 && region_id <= 63

    restored_count = 0

    # Loop through all swapped tiles and restore those in the target region

    @swapped_ground_tiles.keys.each do |key|

      x, y = key[0], key[1]

      # Check if this tile is in the target region

      if region_id(x, y) == region_id

        # Skip tiles with events if requested

        if exclude_events && events_xy(x, y).any?

          next

        end

        # Restore the ground tile

        if restore_ground_tile(x, y)

          restored_count += 1

        end

      end

    end

    force_surface_refresh if restored_count > 0

    return restored_count

  end

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

  # * Check if Ground Tile is Swapped

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Boolean

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

  def ground_tile_swapped?(x, y)

    return @swapped_ground_tiles.has_key?([x, y])

  end

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

  # * Check if Ground Tile is Animated

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Boolean

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

  def ground_tile_animated?(x, y)

    return @animated_ground_tiles.has_key?([x, y])

  end

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

  # * Update Ground Tile Animations (call this from Scene_Map update)

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

  def update_ground_animations

    return unless is_fple? && @fple_map

    return if @animated_ground_tiles.empty?

    @ground_animation_timer += 1

    needs_refresh = false

    @animated_ground_tiles.each do |key, animation_data|

      animation_data[:frame_counter] += 1

      if animation_data[:frame_counter] >= animation_data[:frame_duration]

        # Reset counter and advance frame

        animation_data[:frame_counter] = 0

        animation_data[:current_frame] = (animation_data[:current_frame] + 1) % animation_data[:frames].size

        # Update the tile texture using proper FPLE methods

        x, y = key[0], key[1]

        new_texture_id = animation_data[:frames][animation_data[:current_frame]]

        # Use FPLE's proper method to change ground texture

        success = false

        if @fple_map.respond_to?(:change_ground)

          @fple_map.change_ground(x, y, new_texture_id)

          success = true

        elsif @fple_map.respond_to?(:set_ground_tile)

          @fple_map.set_ground_tile(x, y, new_texture_id)

          success = true

        else

          # Fallback: try to modify the data structure directly

          current_data = @fple_map.get_data(x, y)

          if current_data && current_data.is_a?(Array) && current_data.size > 1

            current_data[1] = new_texture_id

            success = true

          end

        end

        if success

          @swapped_ground_tiles[key] = new_texture_id

          needs_refresh = true

        end

      end

    end

    force_surface_refresh if needs_refresh

  end

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

  # * Get Current Ground Texture ID

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Integer

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

  def get_ground_texture_id(x, y)

    return nil unless valid_coordinates?(x, y) && @fple_map

    tile_data = @fple_map.get_data(x, y)

    return tile_data ? tile_data[1] : nil

  end

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

  # * Get Original Ground Texture ID

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Integer

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

  def get_original_ground_texture_id(x, y)

    key = [x, y]

    if @original_ground_tiles.has_key?(key)

      return @original_ground_tiles[key][1]

    else

      return get_ground_texture_id(x, y)

    end

  end

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

  # * Animate Tile Swap (Simple fade effect)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

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

  def animate_tile_swap(x, y)

    # This is a placeholder for animation

    # In a full implementation, you might want to:

    # - Create temporary sprites for transition effects

    # - Use screen flashes or particle effects

    # - Gradually fade between old and new textures

    $game_map.screen.start_flash(Color.new(255, 255, 255, 60), 10)

    force_surface_refresh

  end

  private

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

  # * Validate Coordinates

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Boolean

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

  def valid_coordinates?(x, y)

    return x >= 0 && x < width && y >= 0 && y < height

  end

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

  # * Force Surface Refresh

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

  def force_surface_refresh

    $game_temp.force_render = true if $game_temp

  end

end

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

# ** Game_Interpreter - Event Commands for Ground Swapping

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

class Game_Interpreter

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

  # * Swap Ground Tile (Event Command)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # param texture_id : Integer - New ground texture ID

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

  def swap_ground(x, y, texture_id)

    $game_map.swap_ground_tile(x, y, texture_id, true)

  end

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

  # * Create Animated Ground Tile (Event Command)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # param base_texture_id : Integer - Base texture ID (uses this +1, +2)

  # param frame_duration : Integer - Frames between animation changes (default: 30)

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

  def animate_ground(x, y, base_texture_id, frame_duration = 30)

    $game_map.create_animated_ground_tile(x, y, base_texture_id, frame_duration, true)

  end

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

  # * Restore Ground Tile (Event Command)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

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

  def restore_ground(x, y)

    $game_map.restore_ground_tile(x, y)

  end

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

  # * Batch Swap Ground Tiles (Event Command)

  # param tile_array : Array - [[x, y, texture_id], ...]

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

  def batch_swap_ground(tile_array)

    $game_map.batch_swap_ground_tiles(tile_array)

  end

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

  # * Restore All Ground Tiles (Event Command)

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

  def restore_all_ground

    $game_map.restore_all_ground_tiles

  end

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

  # * Swap All Ground Tiles in Region (Event Command)

  # param region_id : Integer - Region ID to target (1-63, or 0 for no region)

  # param texture_id : Integer - New ground texture ID

  # param exclude_events : Boolean - Skip tiles with events (optional)

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

  def swap_region_ground(region_id, texture_id, exclude_events = false)

    $game_map.swap_region_ground_tiles(region_id, texture_id, true, exclude_events)

  end

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

  # * Create Animated Ground Tiles for Region (Event Command)

  # param region_id : Integer - Region ID to target

  # param base_texture_id : Integer - Base texture ID (uses this +1, +2)

  # param frame_duration : Integer - Frames between animation changes (default: 30)

  # param exclude_events : Boolean - Skip tiles with events (optional)

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

  def animate_region_ground(region_id, base_texture_id, frame_duration = 30, exclude_events = false)

    $game_map.animate_region_ground_tiles(region_id, base_texture_id, frame_duration, true, exclude_events)

  end

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

  # * Restore All Ground Tiles in Region (Event Command)

  # param region_id : Integer - Region ID to target

  # param exclude_events : Boolean - Skip tiles with events (optional)

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

  def restore_region_ground(region_id, exclude_events = false)

    $game_map.restore_region_ground_tiles(region_id, exclude_events)

  end

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

  # * Check if Ground Tile is Swapped (Event Command)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Boolean

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

  def ground_swapped?(x, y)

    return $game_map.ground_tile_swapped?(x, y)

  end

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

  # * Check if Ground Tile is Animated (Event Command)

  # param x : Integer - X coordinate

  # param y : Integer - Y coordinate

  # return Boolean

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

  def ground_animated?(x, y)

    return $game_map.ground_tile_animated?(x, y)

  end

end

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

# ** Game_Temp - Additional Switches and Variables

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

class Game_Temp

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

  # * Aliased methods

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

  unless @already_aliased_ground_swap_temp

    alias initialize_ground_swap_temp initialize

    @already_aliased_ground_swap_temp = true

  end

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

  # * Public Instance Variables

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

  attr_accessor :ground_swap_animation  # Boolean - Enable swap animations

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

  # * Object Initialization

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

  def initialize

    initialize_ground_swap_temp

    @ground_swap_animation = true

  end

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

  # * Enable/Disable Ground Swap Animations

  # param enabled : Boolean

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

  def set_ground_swap_animation(enabled)

    @ground_swap_animation = enabled

  end

end

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

# ** DataManager - Save/Load Support

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

module DataManager

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

  # * Aliased methods

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

  class << self

    unless @already_aliased_ground_swap_data

      alias make_save_contents_ground_swap make_save_contents

      alias extract_save_contents_ground_swap extract_save_contents

      @already_aliased_ground_swap_data = true

    end

  end

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

  # * Create Save Contents

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

  def self.make_save_contents

    contents = make_save_contents_ground_swap

    contents[:ground_swaps] = {

      :original_tiles => $game_map.original_ground_tiles,

      :swapped_tiles => $game_map.swapped_ground_tiles,

      :animated_tiles => $game_map.animated_ground_tiles

    }

    contents

  end

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

  # * Extract Save Contents

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

  def self.extract_save_contents(contents)

    extract_save_contents_ground_swap(contents)

    if contents[:ground_swaps]

      $game_map.original_ground_tiles = contents[:ground_swaps][:original_tiles] || {}

      $game_map.swapped_ground_tiles = contents[:ground_swaps][:swapped_tiles] || {}

      $game_map.animated_ground_tiles = contents[:ground_swaps][:animated_tiles] || {}

    end

  end

end

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

# ** Scene_Map - Animation Updates

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

class Scene_Map < Scene_Base

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

  # * Aliased methods

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

  unless @already_aliased_ground_swap_scene

    alias update_ground_swap_scene update

    @already_aliased_ground_swap_scene = true

  end

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

  # * Frame Update

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

  def update

    update_ground_swap_scene

    $game_map.update_ground_animations if $game_system.fple

  end

end

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

# ** Usage Examples and Helper Methods

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

# Example usage in events:

#

# Script Command Examples:

# swap_ground(5, 3, 10)                         # Swap tile at (5,3) to texture 10

# animate_ground(5, 3, 15, 60)                  # Animate tile at (5,3) using textures 15,16,17 with 60-frame delays

# animate_ground(2, 4, 20)                      # Animate tile at (2,4) using textures 20,21,22 with default 30-frame delays

# restore_ground(5, 3)                          # Restore original tile at (5,3)

# batch_swap_ground([[1,1,5], [1,2,5]])        # Swap multiple tiles at once

# restore_all_ground                            # Restore all swapped tiles

# swap_region_ground(5, 10)                     # Swap all tiles in region 5 to texture 10

# swap_region_ground(3, 15, true)               # Swap region 3, skip tiles with events

# animate_region_ground(2, 20)                  # Animate all tiles in region 2 using textures 20,21,22

# animate_region_ground(4, 25, 60, true)        # Animate region 4 with 60-frame delays, skip events

# restore_region_ground(5)                      # Restore all tiles in region 5 to original

# restore_region_ground(3, true)                # Restore region 3, skip tiles with events

#

# Conditional Branch Examples:

# if ground_swapped?(5, 3)

#   # Do something if tile is swapped

# end

#

# if ground_animated?(5, 3)

#   # Do something if tile is animated

# end

#

# Advanced Script Examples:

# $game_map.create_animated_ground_tile($game_player.x, $game_player.y, 15, 45)

# $game_map.swap_ground_tile($game_player.x, $game_player.y, 15)

# texture_id = $game_map.get_ground_texture_id(5, 3)

# original_id = $game_map.get_original_ground_texture_id(5, 3)

# count = $game_map.swap_region_ground_tiles(1, 12, false, true)

# $game_map.animate_region_ground_tiles(7, 30, 45)

# Global helper methods for easier access

def swap_ground_tile(x, y, texture_id, animate = true)

  $game_map.swap_ground_tile(x, y, texture_id, animate)

end

def create_animated_ground_tile(x, y, base_texture_id, frame_duration = 30, animate = true)

  $game_map.create_animated_ground_tile(x, y, base_texture_id, frame_duration, animate)

end

def restore_ground_tile(x, y)

  $game_map.restore_ground_tile(x, y)

end

def ground_tile_swapped?(x, y)

  $game_map.ground_tile_swapped?(x, y)

end

def ground_tile_animated?(x, y)

  $game_map.ground_tile_animated?(x, y)

end

def swap_region_ground_tiles(region_id, texture_id, animate = true, exclude_events = false)

  $game_map.swap_region_ground_tiles(region_id, texture_id, animate, exclude_events)

end

def animate_region_ground_tiles(region_id, base_texture_id, frame_duration = 30, animate = true, exclude_events = false)

  $game_map.animate_region_ground_tiles(region_id, base_texture_id, frame_duration, animate, exclude_events)

end

def restore_region_ground_tiles(region_id, exclude_events = false)

  $game_map.restore_region_ground_tiles(region_id, exclude_events)

end

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

# ** FPLE Third Person Player Sprite

# v.1.5 old, now upgraded to v.1.8 using Claude.AI by 5Brainplay. 

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

# This script adds a third-person view sprite of the player character that

# appears on screen during FPLE mode. The sprite can be positioned, scaled,

# and configured to show the player's current state.

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

module FPLE

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

  # * Player Sprite Configuration

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

  PLAYER_SPRITE_DEFAULT_X = 300              # Default X position on screen

  PLAYER_SPRITE_DEFAULT_Y = 450             # Default Y position on screen

  PLAYER_SPRITE_DEFAULT_SCALE = 3.0         # Default scale multiplier

  PLAYER_SPRITE_DEFAULT_OPACITY = 255       # Default opacity (0-255)

  PLAYER_SPRITE_Z = 1000                    # Z-order (higher = in front)

  PLAYER_SPRITE_DEFAULT_ANIMATE = true      # Default enable walking animation

  PLAYER_SPRITE_UPDATE_DIRECTION = false     # Update sprite direction based on player facing

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

  # * Player Sprite Settings (Dynamic)

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

  @@player_sprite_enabled = true

  @@player_sprite_animate = PLAYER_SPRITE_DEFAULT_ANIMATE

  def self.player_sprite_enabled

    @@player_sprite_enabled

  end

  def self.player_sprite_enabled=(value)

    @@player_sprite_enabled = value

  end

  def self.player_sprite_animate

    @@player_sprite_animate

  end

  def self.player_sprite_animate=(value)

    @@player_sprite_animate = value

  end

end

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

# ** FPLE::Player_Sprite

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

module FPLE

  class Player_Sprite < Sprite

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

    # * Object Initialization

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

    def initialize(viewport = nil)

      super(viewport)

      @character = $game_player

      @tile_id = 0

      @character_name = ""

      @character_index = 0

      @pattern = 0

      @direction = 8

      @animation_count = 0

      @stop_count = 0

      @jump_count = 0

      # Set initial position and properties

      self.x = FPLE::PLAYER_SPRITE_DEFAULT_X

      self.y = FPLE::PLAYER_SPRITE_DEFAULT_Y

      self.z = FPLE::PLAYER_SPRITE_Z

      self.zoom_x = FPLE::PLAYER_SPRITE_DEFAULT_SCALE

      self.zoom_y = FPLE::PLAYER_SPRITE_DEFAULT_SCALE

      self.opacity = FPLE::PLAYER_SPRITE_DEFAULT_OPACITY

      update

    end

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

    # * Frame Update

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

    def update

      super

      if FPLE.player_sprite_enabled

        update_bitmap

        update_src_rect

        update_visibility

        update_animation if FPLE.player_sprite_animate

      else

        self.visible = false

      end

    end

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

    # * Update Transfer Origin Bitmap

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

    def update_bitmap

      if graphic_changed?

        @tile_id = @character.tile_id

        @character_name = @character.character_name

        @character_index = @character.character_index

        if @tile_id > 0

          set_tile_bitmap

        else

          set_character_bitmap

        end

      end

    end

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

    # * Determine if Graphic Changed

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

    def graphic_changed?

      @tile_id != @character.tile_id ||

      @character_name != @character.character_name ||

      @character_index != @character.character_index

    end

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

    # * Set Tile Bitmap

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

    def set_tile_bitmap

      sx = (@tile_id / 128 % 2 * 8 + @tile_id % 8) * 32

      sy = @tile_id % 256 / 8 % 16 * 32

      self.bitmap = tileset_bitmap(@tile_id)

      self.src_rect.set(sx, sy, 32, 32)

      self.ox = 16

      self.oy = 32

    end

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

    # * Set Character Bitmap

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

    def set_character_bitmap

      self.bitmap = Cache.character(@character_name)

      sign = @character_name[/^[\!\$]./]

      if sign && sign.include?('$')

        @cw = bitmap.width / 3

        @ch = bitmap.height / 4

      else

        @cw = bitmap.width / 12

        @ch = bitmap.height / 8

      end

      self.ox = @cw / 2

      self.oy = @ch

    end

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

    # * Get Tileset Bitmap

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

    def tileset_bitmap(tile_id)

      set_number = tile_id / 256

      return Cache.system("TileB") if set_number == 0

      return Cache.system("TileC") if set_number == 1

      return Cache.system("TileD") if set_number == 2

      return Cache.system("TileE") if set_number == 3

      return nil

    end

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

    # * Update Transfer Origin Rectangle

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

    def update_src_rect

      if @tile_id == 0

        index = @character.character_index

        pattern = @pattern < 3 ? @pattern : 1

        sx = (index % 4 * 3 + pattern) * @cw

        # Update direction based on player facing if enabled

        if FPLE::PLAYER_SPRITE_UPDATE_DIRECTION

          @direction = @character.direction

        end

        sy = (index / 4 * 4 + (@direction - 2) / 2) * @ch

        self.src_rect.set(sx, sy, @cw, @ch)

      end

    end

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

    # * Update Visibility

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

    def update_visibility

      self.opacity = @character.opacity

      self.blend_type = @character.blend_type

      self.visible = !@character.transparent && FPLE.player_sprite_enabled

    end

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

    # * Update Animation

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

    def update_animation

      if $game_temp.movement

        # Player is moving, animate the sprite

        @stop_count = 0

        update_animation_pattern

      else

        # Player is stationary

        @stop_count += 1

        if @stop_count > 20  # Stop animation after standing still

          @pattern = 1  # Default standing pattern

          @animation_count = 0

        end

      end

    end

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

    # * Update Animation Pattern

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

    def update_animation_pattern

      @animation_count += 1.5

      if @animation_count > 18

        if @pattern == 0

          @pattern = 1

        elsif @pattern == 1

          @pattern = 2

        elsif @pattern == 2

          @pattern = 1

        end

        @animation_count = 0

      end

    end

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

    # * Set Position

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

    def set_position(x, y)

      self.x = x

      self.y = y

    end

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

    # * Set Scale

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

    def set_scale(scale_x, scale_y = nil)

      scale_y = scale_x if scale_y.nil?

      self.zoom_x = scale_x

      self.zoom_y = scale_y

    end

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

    # * Set Direction (for manual control)

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

    def set_direction(direction)

      @direction = direction

    end

  end

end

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

# ** FPLE::Spriteset_Map - Modified

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

# Add player sprite support to the existing FPLE spriteset

module FPLE

  class Spriteset_Map < ::Spriteset_Map

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

    # * Aliased methods for player sprite

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

    unless @already_aliased_player_sprite

      alias create_characters_with_player_sprite create_characters

      alias dispose_characters_with_player_sprite dispose_characters

      alias update_characters_with_player_sprite update_characters

      @already_aliased_player_sprite = true

    end

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

    # * Create Characters (with player sprite)

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

    def create_characters

      create_characters_with_player_sprite

      create_player_sprite

    end

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

    # * Create Player Sprite

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

    def create_player_sprite

      if FPLE.player_sprite_enabled

        @player_sprite = FPLE::Player_Sprite.new(@viewport1)

      end

    end

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

    # * Dispose of Characters (with player sprite)

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

    def dispose_characters

      dispose_player_sprite

      dispose_characters_with_player_sprite

    end

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

    # * Dispose of Player Sprite

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

    def dispose_player_sprite

      if @player_sprite

        @player_sprite.dispose

        @player_sprite = nil

      end

    end

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

    # * Update Characters (with player sprite)

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

    def update_characters

      update_characters_with_player_sprite

      update_player_sprite

    end

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

    # * Update Player Sprite

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

    def update_player_sprite

      if @player_sprite

        @player_sprite.update

      end

    end

  end

end

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

# ** Game_Temp - Player Sprite Commands

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

class Game_Temp

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

  # * Show Player Sprite

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

  def show_player_sprite

    if $game_system.fple

      FPLE.player_sprite_enabled = true

    end

  end

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

  # * Hide Player Sprite

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

  def hide_player_sprite

    if $game_system.fple

      FPLE.player_sprite_enabled = false

    end

  end

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

  # * Set Player Sprite Position

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

  def set_player_sprite_position(x, y)

    if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

      spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

      if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

        spriteset.instance_variable_get(:@player_sprite).set_position(x, y)

      end

    end

  end

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

  # * Set Player Sprite Scale

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

  def set_player_sprite_scale(scale_x, scale_y = nil)

    if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

      spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

      if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

        spriteset.instance_variable_get(:@player_sprite).set_scale(scale_x, scale_y)

      end

    end

  end

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

  # * Get Player Sprite Position

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

  def get_player_sprite_position

    if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

      spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

      if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

        sprite = spriteset.instance_variable_get(:@player_sprite)

        return [sprite.x, sprite.y]

      end

    end

    return [0, 0]

  end

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

  # * Reset Player Sprite to Default Position

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

  def reset_player_sprite_position

    set_player_sprite_position(FPLE::PLAYER_SPRITE_DEFAULT_X, FPLE::PLAYER_SPRITE_DEFAULT_Y)

  end

end

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

# ** Script Call Methods - Global functions for easier access

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

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

# * Simple script call to set player sprite position

# Usage in script call: set_player_sprite_xy(300, 450)

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

def set_player_sprite_xy(x, y)

  if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

    spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

    if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

      spriteset.instance_variable_get(:@player_sprite).set_position(x, y)

    end

  end

end

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

# * Alternative: More direct access to the player sprite

# Usage in script call: player_sprite_position(100, 200)

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

def player_sprite_position(x, y)

  $game_temp.set_player_sprite_position(x, y)

end

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

# * Set individual coordinates

# Usage: set_player_sprite_x(150) or set_player_sprite_y(300)

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

def set_player_sprite_x(x)

  if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

    spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

    if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

      sprite = spriteset.instance_variable_get(:@player_sprite)

      sprite.set_position(x, sprite.y)

    end

  end

end

def set_player_sprite_y(y)

  if $game_system.fple && SceneManager.scene.is_a?(Scene_Map)

    spriteset = SceneManager.scene.instance_variable_get(:@spriteset)

    if spriteset.is_a?(FPLE::Spriteset_Map) && spriteset.instance_variable_get(:@player_sprite)

      sprite = spriteset.instance_variable_get(:@player_sprite)

      sprite.set_position(sprite.x, y)

    end

  end

end

Super Skill Nerf VX

Sat, 06 Sep 2025 20:25:31 +0000

Super Skill Nerf VX

by Kyonides

Introduction

Nerf! Nerf! Nerf your favorite super duper skills!
Yes, even up to the point where your heroes can only use them once per battle!

Mandatory Notes:

Code:

Or Cool Them Down!

Mandatory Note:

Code:

Any positive number will be fine.

And just in case you want to clear this skill use limit once per call:

Code:
$game_party.clear_used_skills!

Or if you prefer to clear the cooldowns altogether:

Code:
$game_party.clear_skill_cooldowns!

VX Scripts

Version 1.3.x

This release includes the ability to change the color of the skill name & its cost based on how many turns are left.
This feature can be modified by editing the constants found in the SkillColor module.

DOWNLOAD DEMOS NOW!

Terms & Conditions

Free as in beer for non commercial games.

Include my nickname in your game credits.

Thank Opozorilo for making the script request. (Optional aka a Joke)

That's it!

KursedVictory VX + ACE

Sat, 06 Sep 2025 05:19:51 +0000

KursedVictory VX + ACE

by Kyonides

Introduction

You will either love this scriptlet or just hate it.
Sometimes the heroes cannot simply obtain a flawless victory. That would be inconceivable!
Thus, they need some final punishment to make sure they learn their lesson!

Just add enemy ID's to the ENEMY_IDS constant to make this happen!

Or leave this note tag in the enemy's notebox: curse_victory

Screenshots

VX Script

Code:
# * KursedVictory VX * #

#   Scripter : Kyonides

#   v1.2.0 - 2025-09-09

# Sometimes the heroes cannot simply obtain a flawless victory. Thus, they need

# some final punishment to make sure they learn their lesson!

# - Method #1

# Just add enemy ID's to the ENEMY_IDS constant to make this happen!

# - Method #2

# Leave a note tag in the enemy's notebox: curse_victory

# Warning: If you refuse to comply, you might have to fight another troop...

module KursedVictory

  BGS = "Darkness"

  CURSOR = "sword0132"

  CURSOR_OY = 4

  OPTION_BACKDROP = "box240"

  MESSAGE = ["Flawless Victory!", "Now choose a curse victim!"]

  OPTIONS = ["Comply", "Refuse"]

  OUTCOME = ["You complied with the %s's demand.",

             "You refused to listen to %s."]

  CURSE_CHANCE = 100

  WAIT_FRAMES = 40

  ENEMY_NOTE_TAG = /curse_victory/i

  ENEMY_IDS = []

  ROUND2_ENEMY_IDS = {}

  ROUND2_ENEMY_IDS[1] = { :name => "Basilisk", :troop_id => 2 }

end

class Game_Enemy

  def cursed_victory_note

    @cursed_victory ||= enemy.note[KursedVictory::ENEMY_NOTE_TAG]

  end

  def curse_victory?

    return true if KursedVictory::ENEMY_IDS.include?(@enemy_id)

    cursed_victory_note != nil

  end

end

class Game_Party

  def dead_members

    members.select {|member| member.dead? }

  end

  def all_dead_now?

    dead_members.size == @actors.size

  end

end

class Game_Troop

  def curse_flawless_victory?

    enemy = @enemies.find {|enemy| enemy.curse_victory? }

    enemy != nil

  end

  attr_reader :troop_id

end

class CursedMessageWindow < Window_Base

  def initialize(wx, wy)

    super(wx, wy, 280, 80)

    refresh

  end

  def refresh

    line1, line2 = KursedVictory::MESSAGE

    font = self.contents.font

    font.bold = true

    font.color.set(220, 80, 0)

    self.contents.draw_text(0, 0, width - 32, 24, line1, 1)

    font.bold = false

    font.color.set(255, 255, 255)

    self.contents.draw_text(0, 24, width - 32, 24, line2, 1)

  end

end

module KursedVictory

  class TextBox

    def initialize(pos, total, vp=nil)

      @index = pos

      @max = total

      @row_max = 2

      @col_max = 1

      @viewport = vp

      @backdrop = Sprite.new(vp)

      @label = Sprite.new(vp)

      @label.z = 50

    end

    def set_image(filename)

      @filename = filename

      set_bitmap

      set_text_bitmap

      reset_alignment

    end

    def set_bitmap

      bitmap = Cache.picture(@filename)

      @width = bitmap.width

      @height = bitmap.height

      @rect = bitmap.rect

      @col_width = Graphics.width

      @center_x = (@col_width - @width) / 2

      @backdrop.bitmap = bitmap

    end

    def set_text_bitmap

      @align_x = 1

      @label.bitmap = Bitmap.new(@width, @height)

    end

    def set_align_xy

      h = @height + 24

      @backdrop.x = @center_x

      @backdrop.y = 140 + @index * h

    end

    def reset_alignment

      set_align_xy

      @label.x = @backdrop.x

      @label.y = @backdrop.y

    end

    def x

      @backdrop.x

    end

    def y

      @backdrop.y

    end

    def set_text(text)

      @text = text

      bit = @label.bitmap

      bit.clear

      bit.draw_text(@rect, text, @align_x)

    end

    def dispose

      @label.bitmap.dispose

      @label.dispose

      @backdrop.bitmap.dispose

      @backdrop.dispose

    end

    attr_reader :text

  end

  class Spriteset

    def initialize

      @curse_viewport = Viewport.new(0, 0, 640, 480)

      @curse_viewport.z = 500

      @curse_boxes = []

      @curse_x = []

      @curse_y = []

      filename = KursedVictory::OPTION_BACKDROP

      options = KursedVictory::OPTIONS

      options.each_with_index do |choice, n|

        box = KursedVictory::TextBox.new(n, options.size, @curse_viewport)

        box.set_image(filename)

        box.set_text(choice)

        @curse_x << box.x

        @curse_y << box.y + KursedVictory::CURSOR_OY

        @curse_boxes << box

      end

      @cursed_cursor = Sprite.new(@curse_viewport)

      @cursed_cursor.x = @curse_x[0]

      @cursed_cursor.y = @curse_y[0]

      @cursed_cursor.z = 100

      @cursed_cursor.bitmap = Cache.picture(KursedVictory::CURSOR)

    end

    def move_cursor(index)

      @cursed_cursor.y = @curse_y[index]

    end

    def dispose

      @curse_boxes.each {|box| box.dispose }

      @cursed_cursor.bitmap.dispose

      @cursed_cursor.dispose

      @curse_viewport.dispose

    end

  end

end

class Scene_Battle

  alias :kyon_kurvic_scn_btl_proc_victor :process_victory

  def process_victory

    process_cursed_victory

    if @cursed_victory and $game_party.all_dead_now?

      process_defeat

      return

    end

    kyon_kurvic_scn_btl_proc_victor

    start_anti_curse_battle if @curse_lifted

  end

  def start_anti_curse_battle

    RPG::BGM.stop

    RPG::BGS.stop

    $game_party.clear_actions

    $game_troop.clear

    $game_troop.setup(@round2_data[:troop_id])

    Sound.play_battle_start

    $game_system.battle_bgm.play

    $scene = Scene_Battle.new

  end

  def process_cursed_victory

    return if KursedVictory::CURSE_CHANCE < rand(100)

    return unless $game_troop.curse_flawless_victory?

    return if $game_party.dead_members.size > 0

    RPG::BGM.stop

    @bgs = RPG::BGS.new(KursedVictory::BGS)

    @bgs.play

    wx = (Graphics.width - 280) / 2

    @cursed_message = CursedMessageWindow.new(wx, 40)

    troop_id = $game_troop.troop_id

    @round2_data = KursedVictory::ROUND2_ENEMY_IDS[troop_id]

    if @round2_data

      process_cursed_victory_options

      return if @curse_lifted

    end

    process_cursed_victory_execution

  end

  def process_cursed_victory_options

    @cursed_spriteset = KursedVictory::Spriteset.new

    @curse_stage = 0

    @curse_index = 0

    @cursed_options = true

    while @cursed_options

      Graphics.update

      Input.update

      update_cursed_victory

    end

  end

  def update_cursed_victory

    case @curse_stage

    when 0

      update_cursed_victory_options

    when 1

      update_cursed_victory_decision

    end

  end

  def update_cursed_victory_options

    if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN)

      Sound.play_cursor

      @curse_index = (@curse_index + 1) % 2

      @cursed_spriteset.move_cursor(@curse_index)

      return

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      name = @round2_data[:name]

      if name

        text = KursedVictory::OUTCOME[@curse_index]

        text = sprintf(text, name)

      end

      @cursed_spriteset.dispose

      if @curse_index == 1

        RPG::BGS.stop

        @cursed_message.dispose

        @curse_lifted = true

      end

      if name

        ow = 460

        $game_message.texts << text

        @curse_stage = 1

      else

        @cursed_options = @curse_stage = nil

      end

    end

  end

  def update_cursed_victory_decision

    @message_window.update

    if Input.trigger?(Input::C)

      Sound.play_decision

      @cursed_options = @curse_stage = nil

    end

  end

  def process_cursed_victory_execution

    @info_viewport.visible = true

    @party_command_window.contents.clear

    @party_command_window.index = -1

    @message_window.visible = false

    @status_window.index = 0

    @status_window.active = true

    @cursed_victory = true

    while @cursed_victory

      Graphics.update

      Input.update

      update_cursed_victory_execution

    end

    KursedVictory::WAIT_FRAMES.times { Graphics.update }

    @cursed_message.dispose

    @info_viewport.visible = false

    @cursed_victory = true

  end

  def update_cursed_victory_execution

    @status_window.update

    if Input.trigger?(Input::C)

      Sound.play_decision

      n = @status_window.index

      $game_party.members[n].add_state(1)

      @status_window.refresh

      @status_window.active = false

      @cursed_victory = nil

    end

  end

end

VX ACE Script

Code:
# * KursedVictory ACE * #

#   Scripter : Kyonides

#   v1.2.0 - 2025-09-09

# Sometimes the heroes cannot simply obtain a flawless victory. Thus, they need

# some final punishment to make sure they learn their lesson!

# - Method #1

# Just add enemy ID's to the ENEMY_IDS constant to make this happen!

# - Method #2

# Leave a note tag in the enemy's notebox: curse_victory

# Warning: If you refuse to comply, you might have to fight another troop...

module KursedVictory

  BGS = "Darkness"

  CURSOR = "sword0132"

  CURSOR_OY = 4

  OPTION_BACKDROP = "box240"

  MESSAGE = ["Flawless Victory!", "Now choose a curse victim!"]

  OPTIONS = ["Comply", "Refuse"]

  OUTCOME = ["You complied with the %s's demand.",

             "You refused to listen to %s."]

  CURSE_CHANCE = 100

  WAIT_FRAMES = 40

  ENEMY_NOTE_TAG = /curse_victory/i

  ENEMY_IDS = []

  ROUND2_ENEMY_IDS = {}

  ROUND2_ENEMY_IDS[1] = { :name => "Basilisk", :troop_id => 2 }

end

class Game_Enemy

  def cursed_victory_note

    @cursed_victory ||= enemy.note[KursedVictory::ENEMY_NOTE_TAG]

  end

  def curse_victory?

    return true if KursedVictory::ENEMY_IDS.include?(@enemy_id)

    cursed_victory_note != nil

  end

end

class Game_Party

  def dead_members

    members.select {|member| member.dead? }

  end

  def all_dead_now?

    dead_members.size == @actors.size

  end

end

class Game_Troop

  def curse_flawless_victory?

    enemy = @enemies.find {|enemy| enemy.curse_victory? }

    enemy != nil

  end

  attr_reader :troop_id

end

class CursedMessageWindow < Window_Base

  def initialize(wx, wy)

    super(wx, wy, 280, 76)

    refresh

  end

  def refresh

    line1, line2 = KursedVictory::MESSAGE

    font = self.contents.font

    font.bold = true

    font.color.set(220, 80, 0)

    self.contents.draw_text(0, 0, width - 32, 24, line1, 1)

    font.bold = false

    font.color.set(255, 255, 255)

    self.contents.draw_text(0, 26, width - 32, 24, line2, 1)

  end

end

module KursedVictory

  class Message < Window_Base

    def set_text(text)

      contents.clear

      contents.draw_text(0, 0, contents.width, 24, text)

      self.visible = true

      self.pause = true

    end

  end

  class TextBox

    def initialize(pos, total, vp=nil)

      @index = pos

      @max = total

      @row_max = 2

      @col_max = 1

      @viewport = vp

      @backdrop = Sprite.new(vp)

      @label = Sprite.new(vp)

      @label.z = 50

    end

    def set_image(filename)

      @filename = filename

      set_bitmap

      set_text_bitmap

      reset_alignment

    end

    def set_bitmap

      bitmap = Cache.picture(@filename)

      @width = bitmap.width

      @height = bitmap.height

      @rect = bitmap.rect

      @col_width = Graphics.width

      @center_x = (@col_width - @width) / 2

      @backdrop.bitmap = bitmap

    end

    def set_text_bitmap

      @align_x = 1

      @label.bitmap = Bitmap.new(@width, @height)

    end

    def set_align_xy

      h = @height + 24

      @backdrop.x = @center_x

      @backdrop.y = 140 + @index * h

    end

    def reset_alignment

      set_align_xy

      @label.x = @backdrop.x

      @label.y = @backdrop.y

    end

    def x

      @backdrop.x

    end

    def y

      @backdrop.y

    end

    def set_text(text)

      @text = text

      bit = @label.bitmap

      bit.clear

      bit.draw_text(@rect, text, @align_x)

    end

    def dispose

      @label.bitmap.dispose

      @label.dispose

      @backdrop.bitmap.dispose

      @backdrop.dispose

    end

    attr_reader :text

  end

  class Spriteset

    def initialize

      @curse_viewport = Viewport.new

      @curse_viewport.z = 500

      @curse_boxes = []

      @curse_x = []

      @curse_y = []

      filename = KursedVictory::OPTION_BACKDROP

      options = KursedVictory::OPTIONS

      options.each_with_index do |choice, n|

        box = KursedVictory::TextBox.new(n, options.size, @curse_viewport)

        box.set_image(filename)

        box.set_text(choice)

        @curse_x << box.x

        @curse_y << box.y + KursedVictory::CURSOR_OY

        @curse_boxes << box

      end

      @cursed_cursor = Sprite.new(@curse_viewport)

      @cursed_cursor.x = @curse_x[0]

      @cursed_cursor.y = @curse_y[0]

      @cursed_cursor.z = 100

      @cursed_cursor.bitmap = Cache.picture(KursedVictory::CURSOR)

    end

    def move_cursor(index)

      @cursed_cursor.y = @curse_y[index]

    end

    def dispose

      @curse_boxes.each {|box| box.dispose }

      @cursed_cursor.bitmap.dispose

      @cursed_cursor.dispose

      @curse_viewport.dispose

    end

  end

end

class << BattleManager

  alias :kyon_kurvic_btlman_proc_victor :process_victory

  def process_victory

    process_cursed_victory

    if @cursed_victory and $game_party.all_dead_now?

      process_defeat

      return true

    end

    kyon_kurvic_btlman_proc_victor

    start_anti_curse_battle if @curse_lifted

    @curse_lifted = nil

    true

  end

  def process_cursed_victory

    return if KursedVictory::CURSE_CHANCE < rand(100)

    return unless $game_troop.curse_flawless_victory?

    return if $game_party.dead_members.size > 0

    RPG::BGM.stop

    @bgs = RPG::BGS.new(KursedVictory::BGS)

    @bgs.play

    @scene = SceneManager.scene

    @scene.create_cursed_message

    @scene.start_cursed_victory

  end

  def start_anti_curse_battle

    RPG::BGM.stop

    RPG::BGS.stop

    $game_party.clear_actions

    $game_troop.clear

    $game_troop.setup(@next_troop_id)

    @next_troop_id = nil

    Sound.play_battle_start

    BattleManager.play_battle_bgm

    SceneManager.call(Scene_Battle)

  end

  attr_writer :cursed_victory, :next_troop_id

  attr_accessor :curse_lifted

end

class Scene_Battle

  def create_cursed_message

    wx = (Graphics.width - 280) / 2

    @cursed_message = CursedMessageWindow.new(wx, 40)

    @info_viewport.visible = true

    @party_command_window.contents.clear

    @party_command_window.index = -1

    @message_window.visible = false

    @status_window.index = 0

    @status_window.active = true

    @outcome_window = KursedVictory::Message.new(0, 288, 544, 128)

    @outcome_window.visible = false

  end

  def start_cursed_victory

    troop_id = $game_troop.troop_id

    @round2_data = KursedVictory::ROUND2_ENEMY_IDS[troop_id]

    if @round2_data

      process_cursed_victory_options

      return if BattleManager.curse_lifted

    end

    process_cursed_victory_execution

  end

  def process_cursed_victory_options

    @cursed_spriteset = KursedVictory::Spriteset.new

    @curse_stage = 0

    @curse_index = 0

    while @curse_stage

      Graphics.update

      Input.update

      update_cursed_victory

    end

  end

  def update_cursed_victory

    case @curse_stage

    when 0

      update_cursed_victory_options

    when 1

      update_cursed_victory_decision

    end

  end

  def update_cursed_victory_options

    if Input.trigger?(:UP) or Input.trigger?(:DOWN)

      Sound.play_cursor

      @curse_index = (@curse_index + 1) % 2

      @cursed_spriteset.move_cursor(@curse_index)

      return

    elsif Input.trigger?(:C)

      Sound.play_ok

      name = @round2_data[:name]

      if name

        text = KursedVictory::OUTCOME[@curse_index]

        text = sprintf(text, name)

      end

      @cursed_spriteset.dispose

      if @curse_index == 1

        RPG::BGS.stop

        BattleManager.curse_lifted = true

        BattleManager.next_troop_id = @round2_data[:troop_id]

        @cursed_message.dispose

        @cursed_message = nil

      end

      if name

        @outcome_window.set_text(text)

        @status_window.visible = false

        @curse_stage = 1

      else

        @curse_stage = nil

      end

    end

  end

  def update_cursed_victory_decision

    @outcome_window.update

    if Input.trigger?(:C)

      Sound.play_ok

      state = @curse_index == 0

      BattleManager.cursed_victory = state

      @status_window.visible = state

      @message_window.visible = !state

      @outcome_window.dispose

      @outcome_window = @curse_stage = nil

    end

  end

  def process_cursed_victory_execution

    while @curse_index

      Graphics.update

      Input.update

      update_cursed_victory_execution

    end

    KursedVictory::WAIT_FRAMES.times { Graphics.update }

    @message_window.visible = true

    @cursed_message.dispose

    @cursed_message = nil

  end

  def update_cursed_victory_execution

    @status_window.update

    if Input.trigger?(:C)

      Sound.play_ok

      n = @status_window.index

      $game_party.members[n].add_state(1)

      BattleManager.cursed_victory = nil

      @status_window.refresh

      @status_window.active = false

      @curse_index = nil

    end

  end

end

Terms & Conditions

Free as in beer for non commercial games.
Include my nickname in your game credits.
That's it!

KMustDie VX + ACE

Wed, 03 Sep 2025 05:47:42 +0000

KMustDie VX + ACE

by Kyonides

Imagine a game world where certain battles won't force you to kill ALL of the enemy troops on screen.
Well, you can stop doing that right away because now you can make your battle dream come true!
Just set which troops are mandatory to kill via a script call and that's it!
You won't have to depend on a tough negotiator to deal with tyrants looking for free lands up for the grabs.

Script Call - Use natural index values like 1 upto 8 here:

Code:
$game_troop.must_die(EnemyIndex1, etc.)

VX Script

Code:
# * KMustDie VX * #

#   Scripter : Kyonides

#   v1.0.1 - 2025-09-06

# This scriptlet allows you to set a given number of enemies that must die in

# battle before the player can be proclaimed as the victor there.

# * Script Call * #

# - Enter 1+ Enemy Indexes to set which enemies should die before battle ends.

#   You should use number 1 as the first position available there.

# $game_troop.must_die(EnemyIndex1, etc.)

class Game_Troop

  alias :kyon_must_die_gm_trp_init :initialize

  attr_reader :hunt_targets

  def initialize

    kyon_must_die_gm_trp_init

    @hunt_targets = [] 

  end

  def dead_now

    @enemies.select {|e| e.dead? }

  end

  def hunt_targets_dead?

    targets = dead_now.map {|e| e.index + 1 }

    @hunt_targets.any? and targets.sort == @hunt_targets

  end

  def must_die(*targets)

    @hunt_targets = targets.sort

  end

end

class Scene_Battle

  alias :kyon_must_die_scn_btl_judge :judge_win_loss

  alias :kyon_must_die_scn_btl_blt_end :battle_end

  def judge_win_loss

    if $game_troop.hunt_targets_dead?

      process_victory

      return true

    else

      kyon_must_die_scn_btl_judge

    end

  end

  def battle_end(result)

    $game_troop.hunt_targets.clear

    kyon_must_die_scn_btl_blt_end(result)

  end

end

VX ACE Script

Code:
# * KMustDie ACE * #

#   Scripter : Kyonides Arkanthes

#   v1.0.1 - 2025-09-06

# This scriptlet allows you to set a given number of enemies that must die in

# battle before the player can be proclaimed as the victor there.

# * Script Call * #

# - Enter 1+ Enemy Indexes to set which enemies should die before battle ends.

#   You should use number 1 as the first position available there.

# $game_troop.must_die(EnemyIndex1, etc.)

class Game_Troop

  alias :kyon_must_die_gm_trp_init :initialize

  attr_reader :hunt_targets

  def initialize

    kyon_must_die_gm_trp_init

    @hunt_targets = [] 

  end

  def dead_now

    members.select {|e| e.dead? }

  end

  def hunt_targets_dead?

    targets = dead_now.map {|e| e.index + 1 }

    @hunt_targets.any? and targets.sort == @hunt_targets

  end

  def must_die(*targets)

    @hunt_targets = targets.sort

  end

end

class << BattleManager

  alias :kyon_must_die_btlman_judge :judge_win_loss

  alias :kyon_must_die_btlman_blt_end :battle_end

  def judge_win_loss

    if $game_troop.hunt_targets_dead?

      process_victory

      return true

    else

      kyon_must_die_btlman_judge

    end

  end

  def battle_end(result)

    $game_troop.hunt_targets.clear

    kyon_must_die_btlman_blt_end(result)

  end

end

DOWNLOAD DEMOS!

Terms & Conditions

Free as in beer for non-commercial games.
Include my nickname in your game credits.
That's it!

KChangeCmdMsg VX + ACE

Wed, 23 Jul 2025 01:31:47 +0000

KChangeCmdMsg VX + ACE

by Kyonides

Introduction

This scriptlet is very practical. It allows you to predefine a message that will include both the object's name and the total amount of things the party has gain or lost just a split second ago. You will no longer need to click on the Show Text event command ever again to inform the player about those changes.

That's laziness at its best!

NOTES:

The FOUND_MSG & LOST_MSG constants contain the automated earn & lost messages. Feel free to change them at will.
Yet, you can also customize both JOIN_MSG and LEAVE_MSG if you want to add your personal touch to this new automated message.

I know VX & VX ACE already offer a way to quickly create a automated message, yet, this one allows you to find several items in a row at the same spot without any complications. And you can still add any other event commands to your event command list.

DOWNLOAD DEMOS

Terms & Conditions

If you know how to use the engine, that's enough for me!
Of course, I wouldn't mind if you include me in your game credits.
That's it!

Command Color VX + ACE

Mon, 16 Jun 2025 02:29:20 +0000

Command Color VX + ACE

by Kyonides

Did you ever want to change your command window's currently selected command a little bit?
Now you can do it!
This scriptlet lets you alter its color!

Just configure the SELECT_COLOR constant accordingly and that's it!

VX Script

Code:
# * Command Color VX * #

#   Scripter : Kyonides

#   v0.5.0 - 2025-06-15

# The SELECT_COLOR Constant lets you configure your custom color following

# the usual (R,G,B) or (R,G,B,A) color format.

class Window_Command

  SELECT_COLOR = Color.new(255, 255, 0)

  DISABLED_ALPHA = 100

  alias :kyon_cmd_clr_win_comm_init :initialize

  alias :kyon_cmd_clr_win_comm_set_index :index=

  alias :kyon_cmd_clr_win_comm_draw_item :draw_item

  alias :kyon_cmd_clr_win_comm_up :update

  def initialize(width, commands)

    @disabled = []

    @last_pos = -1

    kyon_cmd_clr_win_comm_init(width, commands)

  end

  def disable_item(index)

    @disabled << index

    @disabled = @disabled.sort.uniq

  end

  def draw_item(index, enabled = true)

    disable_item(index) unless enabled

    kyon_cmd_clr_win_comm_draw_item(index, enabled)

  end

  def draw_item_color(n, current)

    rect = item_rect(n)

    rect.x += 4

    rect.width -= 8

    b = self.contents

    b.clear_rect(rect)

    new_color = current ? SELECT_COLOR.dup : normal_color.dup

    new_color.alpha = DISABLED_ALPHA if @disabled.include?(n)

    b.font.color = new_color

    b.draw_text(rect, @commands[n])

  end

  def index=(new_index)

    return if @index == new_index

    if @index >= 0

      draw_item_color(@index, nil)

      @last_pos = @index

    end

    kyon_cmd_clr_win_comm_set_index(new_index)

    draw_item_color(@index, true)

  end

  def update_command

    return if @last_pos == @index

    draw_item_color(@last_pos, nil) if @last_pos >= 0

    draw_item_color(@index, true)

    @last_pos = @index

  end

  def update

    kyon_cmd_clr_win_comm_up

    update_command

  end

end

VX ACE Script

Code:
# * Command Color ACE * #

#   Scripter : Kyonides

#   v0.5.1 - 2025-09-10

# The SELECT_COLOR Constant lets you configure your custom color following

# the usual (R,G,B) or (R,G,B,A) color format.

class Window_Command

  SELECT_COLOR = Color.new(255, 255, 0)

  def no_commands?

    @list.empty?

  end

  def clear_old_item(n)

    return if @index == n

    clear_item(@index)

    draw_item(@index)

  end

  def draw_new_item(index)

    change_color(SELECT_COLOR, command_enabled?(index))

    draw_text(item_rect_for_text(index), command_name(index), alignment)

  end

  def select(n)

    if no_commands?

      self.index = n if n

      return

    end

    clear_old_item(n)

    self.index = n if n

    draw_new_item(@index) if @index == n

  end

end

Terms & Use

Free as in beer.
Crediting me as the author is optional.
That's it!

Animated Message Profiles VX

Mon, 09 Jun 2025 20:16:16 +0000

Animated Message Profiles VX
Version: 1.1

Introduction

This is an add-on for the default message systems, or for those custom message systems that are compliant. It permits the game developer to present an image behind the default message window, and even allow for the image to display cel animation properties.

Essentially, one can present characters that appear to be talking.

Script

Instructions/Configuration

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

# ** Animated Message Profiles VX

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

#    by DerVVulfman

#    Version 1.1

#    06-14-2025 (MM/DD/YYYY)

#    RGSS2 / RPGMaker VX

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

#

#                     > INSTRUCTION / CONFIGURATION PAGE <

#

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

#

#  INTRODUCTION:

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

#

#  This is an add-on for the default message systems, or for those custom mes-

#  sage systems that are compliant.  It permits the game developer  to present  

#  an image behind the default message window, and even allow for the image to

#  display cel animation properties.

#

#  Essentially, one can present characters that appear to be talking.

#

#

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

#

#  INSTALLATION:

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

#

#  At bare minimum,  place both the Instruction / Configuration and the Engine

#  scripts below Scene_Debug and above Main.  

#

#  The configuration page defines the actual profiles that are displayed,  the

#  location where they are shown, and if they are indeed animated.

#

#

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

#

#  CONFIGURATION SETTINGS:

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

#

#  The configuration section has two areas to adjust, the first is the setting

#  that determines  if the profile shows  when the message 'begins' to show or 

#  waits until the message display is complete,  and the second is the list of

#  profiles themselves.  These profiles are the images or renders of the char-

#  acters that appear beind the message window, whether animated or not.

#

#  Profiles are defined within a hash array.  Each of these profiles are iden-

#  tified by a key,  a string value that can be easily referenced. And each of

#  these profiles points to an array indicating where the profiles are placed,

#  the speed in which the profiles circulate between animated frames,  and the

#  list of one (or more) profile animation frames.

#  

#    Syntax:  DATA[key]  = [ xpos, ypos, speed, repeat img, img, img... img ]

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

#    * key:    A string (in quotes) that separates it from other profiles.

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

#    * xpos:   X-Position or Coordinates where the sprite(s) will draw.

#    * ypos:   Y-Position or Coordinates where the sprite(s) will draw.

#    * speed:  (in frames per second) The number of frames between each image.

#    * repeat: (a true/false value) Indicating if multiple images repeat

#    * img:    An image file (or set of file) in the Graphics\Pictures folder.

#

#  You can show one single image behind the message box with the following

#  example:

#  DATA["LunarSmile"]  =   [50,120,4,true'actor1']

#  -- or --

#  DATA["LunarSmile"]  =   [50,120,4,true'actor1']

#

#  Or, you can render a profile that draws three images in the pictures folder

#  in rapid succession like so:

#

#  DATA["ZeldaIsLaughing"]  = [50,120,4, true 'actor1','actor1a','actor1b']

#  -- if the animation continues until closed --

#  DATA["ZeldaIsLaughing"]  = [50,120,4, false 'actor1','actor1a','actor1b']

#  -- if the animation ends after all three images have been shown --

#

#

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

#

#  MESSAGE WINDOW COMMANDS:

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

#

#  DISPLAYING THE PROFILE:

#

#  You may display a profile by using the Message Code:  \AB[key].

#

#  While the key must have quotes when defined in the module, the message

#  code's key value does not use quotes.

#  

#  EX:  \ab[ZeldaIsLaughing]That is so funny!!!

#

#  The above example would display an animated profile with the defined

#  profile name of 'ZeldaIsLaughing' with text following immediately.

#

#  Alternately, you may use a script call prior to the display of the 

#  message with the 'set_profile' command like so:

#    @>Script: set_profile("ZeldaIsLaughing")

#    @>Text: That is so funny!!!!"

#

#                             -    -    -    -    -

#

#  HOLDING A PROFILE PRESENT

#

#  Normally, the image vanishes when you close a window. However, there may be

#  instances where a character is delivering multiple message windows of text

#  and you want the image to remain for the very next message.

#

#  For this, you need to apply the 'hold_profile' script call on the message

#  the contains the current profile.  This is to prevent it from erasing the

#  profile before the message ends.  This may appear like so:

#

#    @>Script: set_profile("ZeldaIsLaughing")

#    @>Script: hold_profile

#    @>Text: That is so funny!!!!"

#    @>Text: I am just laughing uncontrollably!!!!"

#

#  This example would use the same profile image for both messages.  However,

#  the below exaple would have its third message window without the profile.

#

#    @>Script: set_profile("ZeldaIsLaughing")

#    @>Script: hold_profile

#    @>Text: That is so funny!!!!"

#    @>Text: I am just laughing uncontrollably!!!!"

#    @>Text: Okay, I'm done now."

#

#  To continue with the image remaining in place, you must use the hold_profile

#  command before each message that you want to PREVENT the profile's erasure.

#

#                             -    -    -    -    -

#

#  SWAPPING A PROFILE PRESENT

#

#  For use in tandem with the above  'hold_profile' call,  this is a special

#  command that lets you switch  from one profile set to another without the

#  profile sprite erasing.  Unlike the hold_profile call, the 'swap_profile'

#  is run right before the new message is shown, and used in tandem with the

#  application of a new profile like so:

#   

#    @>Script: set_profile("ZeldaIsLaughing")

#    @>Script: hold_profile

#    @>Text: That is so funny!!!!"

#    @>Script: swap_profile

#    @>Text: \AB[ZeldaCry]Waaahhh!"

#

#  This would provide a more seamless change in character behavior between

#  messages without the character needing to vanish and be redrawn.

#

#

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

#

#  PAPERDOLL/BITMAP COMPATABILITY:

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

#

#  paper doll (noun)

#   1. A paper or cardboard representation of a person usually in two dimen-

#      sions for children to play with. 

#   2. Figures cut out of paper or thin card, with separate clothes, also made

#      of paper, that are usually held onto the dolls by paper folding tabs.

#

#  Sometimes called a Visual Equipment script,  a paperdoll system is one that

#  can change a character's appearance based on the gear attached.

#

#  While Animated Message Profiles does not have  a built-in paperdoll system,

#  it contains an area where changes to a profile's appearance may be made. It

#  is within the Window_Message class, and is a specifically defined method to

#  grant a would-be scripter access to the bitmaps to adjust.

#

#  In short, I made a method a scripter can mess with. ^_^   

#

#  Line # 331:  update_profile_reader

#

#

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

#

#  NOTES ON THE EXAMPLE CONFIG:

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

#

#  The two profiles are using images found in the 'Graphics\Profiles' folder.

#  And in that folder, there are only two files, "Ikuno1.png" & "Ikuno2.png".

#  

#  You use multiple image files to creat an animation, and at least one file

#  to create a portrait if static and not animated.

#

#  The first profile is that of "Ikuno".  The profile will appear  at coordi-

#  nates  80,140  which would line up nice with the default message window if

#  it is at the bottom of the screen.  The speed is set to 4, which means the

#  individual cels change after 4 frames (in framerate).  It is set to false,

#  this indicates it will only cycle through all the animation cels once. And

#  it only has two images:  "Ikuno1.png" and "Ikuno2.png". This means that it

#  only plays the two images in sequence once... and stops.

#

#  The second profile is that of "Ikuno2". The profile will appear  at coordi-

#  nates  80,140  the same as the first. The speed is set to 0, however, this

#  is an illegal value  as the animation speed rate cannot go below '1'.  The

#  repeat value is set to 'true' so it will play every animation frame in its

#  set over and over aggain.  And it lists "Ikuno1", "Ikuno2" and "Ikuno1".

#

#  The third profile is that of "Ikuno3".  And this one is merely a static,

#  one frame/image profile.  Ergo, it will not appear animated.

#

#                             -    -    -    -    -

#

#  Example I used with the three profile settings:

#

#

#    @>Script: hold_profile

#    @>Text: \AB[Ikuno]What? Yeah, my mouth isn't moving.

#    @>Script: swap_profile

#    @>Text: \AB[Ikuno2]Yap Yap Yap!

#    @>Text: Peekaboo... you don't see me

#    @>Script: set_profile("Ikuno3")

#    @>Text: Now you do.

#

#

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

#

#  VERSION HISTORY:

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

#  YYYY MM DD

#  2025-06-09 - Original release

#  2025-06-14 - Fix: Disposed portrait sprite issue and increased z-depth

#

#

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

#

#  COMPATABILITY:

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

#

#  Designed for message systems compliant with RPGMaker VX's default system.

#  All default scripts aliased.

#

#

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

#

#  TERMS AND CONDITIONS:

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

#

#  Free to use,  even in commercial projects.  However, I will need some form

#  of due credit.

#

#

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

module Profiles

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

  DATA = {} # Do Not Touch

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

  # Do profiles show when beginning to render?

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

  SHOW_ON_OPENING = false

  # PROFILE LIST

  #

  # Profile w Key     X     Y     Spd   Repeat  Animation frames...

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

  DATA["Ikuno"]   = [ 80,   140,  4,    false,  'Ikuno1', 'Ikuno2' ]

  DATA["Ikuno2"]  = [ 80,   140,  0,    true,   'Ikuno1', 'Ikuno2', 'Ikuno1' ]

  DATA["Ikuno3"]  = [ 80,   140,  0,    false,  'Ikuno2' ]

end

Main Code

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

# ** Animated Message Profiles VX

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

#    by DerVVulfman

#    Version 1.1

#    06-14-2025 (MM/DD/YYYY)

#    RGSS2 / RPGMaker VX

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

#

#                             > MAIN SYSTEM PAGE <

#

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

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

# ** Cache

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

#  This module loads each of graphics, creates a Bitmap object, and retains it.

# To speed up load times and conserve memory, this module holds the created

# Bitmap object in the internal hash, allowing the program to return

# preexisting objects when the same bitmap is requested again.

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

module Cache

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

  # * Profile image

  #     filename : filename of the cached bitmap

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

  def self.profiles(filename)

    #

    begin

      self.load_bitmap("Graphics/Profiles/", filename)

    rescue 

      self.load_bitmap("Graphics/Profiles/", "")

    end

    #

  end

end

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

# ** Game_System

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

#  This class handles system-related data. Also manages vehicles and BGM, etc.

# The instance of this class is referenced by $game_system.

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

class Game_System

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

  # * Public Instance Variables

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

  attr_accessor :profile_name             # Name of profile image data

  attr_accessor :profile_hold             # Profile do not erase flag

  attr_accessor :profile_swap 

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

  # * Alias Listings

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

  alias msg_profiles_game_system_initialize initialize

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

  # * Object Initialization

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

  def initialize

    #

    msg_profiles_game_system_initialize

    @profile_name       = nil

    @profile_hold       = false

    @profile_swap       = false

    #

  end

end

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

# ** Game_Interpreter

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

#  An interpreter for executing event commands. This class is used within the

# Game_Map, Game_Troop, and Game_Event classes.

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

class Game_Interpreter

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

  # * Set Message Profile outside of Show Text box

  #     key : key as defined in the Profiles Module

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

  def set_profile(key=nil)

    #

    if key.nil?                                   # If no valid key supplied

      $game_system.profile_name = nil             # ..set erased profile name

      return                                      # ..and exit method.

    end

    unless Profiles::DATA.has_key?(key)           # If no valid profile given

      $game_system.profile_name = nil             # ..set erased profile name

      return                                      # ..and exit method.

    end

    $game_system.profile_name = key               # Set the profile name

    #

  end

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

  # * Set image hold/freeze to use in next message

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

  def hold_profile

    #

    $game_system.profile_hold = true              # Set the profile hold flag

    #

  end

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

  # * Set sprite frozent to allow profile image and animation swapping

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

  def swap_profile

    #

    $game_system.profile_swap = true              # Set the profile swap flag

    #

  end

end

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

# ** Window_Message

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

#  This message window is used to display text.

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

class Window_Message < Window_Selectable

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

  # * Alias Listings

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

  alias msg_profiles_windows_initialize initialize

  alias msg_profiles_windows_dispose dispose

  alias msg_profiles_windows_update update

  alias msg_profiles_windows_csc convert_special_characters

  alias msg_profiles_windows_terminate_message terminate_message

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

  # * Original methods Aliased

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

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

  # * Object Initialization

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

  def initialize

    #

    msg_profiles_windows_initialize               # Run the original method

    initialize_message_profile                    # Create profile data

    #

  end

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

  # * Dispose

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

  def dispose

    #

    @profile.dispose                              # Dispose of profile sprite

    msg_profiles_windows_dispose                  # Run the original method

    #

  end

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

  # * Frame Update

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

  def update

    #

    deny_flag = @closing                         # Set deny flag on closing 

    unless Profiles::SHOW_ON_OPENING             # If opening is denied

      deny_flag = true if @opening               # ...set flag if also opening

    end

    unless deny_flag                              # Unless denied from showing  

      update_message_profile                      # Perform update if showing

    end

    msg_profiles_windows_update                   # Run the original method

    #

  end

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

  # * Convert Special Characters

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

  def convert_special_characters

    #

    convert_special_characters_profile            # Perform profile refresh

    msg_profiles_windows_csc                      # Run the original method

    #

  end

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

  # * Terminate Message

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

  def terminate_message

    #

    msg_profiles_windows_terminate_message        # Run the original method

    terminate_message_profile                     # Terminate profile data

    #

  end

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

  # * New Content

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

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

  # * Object Initialization : Creation of clear profile data variables

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

  def initialize_message_profile

    #

    @profile          = Sprite.new                # Create the profile sprite

    @profile.z        = self.z - 5                # Set it behind the message

    @msgprofile       = []                        # Create empty filename array

    @msgwait_count    = 0                         # Reset the wait count

    @profilerepeat    = true                      # Reset repeat function

    #

  end

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

  # * Frame Update:  Profile display and animation

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

  def update_message_profile

    #

    unless $game_system.profile_swap              # Unless swapping profiles

      return if @profilerepeat == false           # Exit method on no repeat

    end

    #

    if @msgwait_count > 0                         # If a wait count exists

      @msgwait_count -= 1                         # ..reduce the wait count

      return                                      # ..and exit the method 

    end

    #

    update_profile_generator                      # Run the profile generator

    #

    return if @bitmap.nil?                        # Exit if not valid bitmap 

    return if @profile.bitmap.nil?                # Exit if no profile bitmap

    return if @pattern.nil?                       # Exit if no defined pattern

    return if @sprite_numbers.nil?                # Exit if no sprite number set

    return if @msgprofile.nil?                    # Exit if no configed profile 

    #

    @pattern = (@pattern + 1) % @sprite_numbers   # Set animation pattern

    if @pattern == (@sprite_numbers-1)            # If at end of loop

      @profilerepeat = @msg_repeat                # .. determine if repeating

    end

    #

    sx = @pattern * @cw                           # Define which image to use

    src_rect = Rect.new(sx, 0, @cw, @ch)          # Acquire the sprite image

    @profile.bitmap.clear                         # Clear the sprite bitmap

    @profile.bitmap.blt(0, 0, @bitmap, src_rect)  # Apply the new bitmap

    @msgwait_count  = @msg_count                  # Reset the wait count 

    @profile.visible = true                       # Show the provile sprite 

    #

  end

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

  # * Update:  Generate the Profile Animation Strip

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

  def update_profile_generator

    #

    return if $game_system.profile_name.nil?       # Exit if no profile name

    return if $game_system.profile_name == ""      # Exit if profile name empty

    name   = $game_system.profile_name             # Get the profile name

    #

    return unless update_profile_empty?            # Exit if exist or is to swap

    return if Profiles::DATA.nil?                  # Exit if no configured data

    return unless Profiles::DATA.has_key?(name)    # Exit if no profile configed

    #

    if $game_system.profile_swap == true           # If profiles are swapped

      @profilerepeat = true                        # Ensure repeat at restart

    end

    #

    unless $game_system.profile_swap == true      # If profiles are not swapped

      @profile        = Sprite.new                # ..make a new profile sprite

    end

    #

    @msgprofile     = Profiles::DATA[name]        # Acquire configured profile 

    @profile.z      = self.z - 5                  # Set profile behind message

    @profile.x      = @msgprofile[0]              # Set x-coordinate of profile

    @profile.y      = @msgprofile[1]              # Set y-coordinate of profile

    @msg_count      = @msgprofile[2]              # Set Message wait count

    @msg_repeat     = @msgprofile[3]              # Set Message repeat flag

    files           = @msgprofile[4]              # Set first file in list

    @msg_count      = 1 if @msg_count < 1         # Set wait count minimum

    @pattern        = 0                           # Reset profile pattern

    #

    @sprite_numbers = @msgprofile.size-4          # Get size of configed profile

    bitmap          = Cache.profiles(files)       # Set first bitmap

    @cw             = bitmap.width                # Get profile strip width

    @ch             = bitmap.height               # Get character height

    width           = @cw * @sprite_numbers       # Get single-image width

    @bitmap         = Bitmap.new(width, @ch)      # Create simgle-image bitmap

    #

    for i in 0...@sprite_numbers                  # Cycle through sprites

      src = update_profile_reader(@msgprofile,i)  # Acquire individual sprite

      src_rect    = Rect.new(0, 0, @cw, @ch)      # Acquire sprite rectangle

      @bitmap.blt(@cw*i, 0, src, src_rect)        # Blit sprite

    end

    #

    @profile.bitmap  = Bitmap.new(@cw, @ch)       # Create clean profile bitmap

    @profile.visible = true                       # Make visible

    $game_system.profile_swap = false             # And clear swap flag

    #

  end

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

  # * Update:  Testing if there is no image, or if image is to be replaced.

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

  def update_profile_empty?

    #

    if $game_system.profile_swap == true          # If swapping profiles set

      return true                                 # ..Exit method true

    end

    if @profile.bitmap.nil?                       # If there is no bitmap

      return true                                 # ..Exit method true

    end

    return false                                  # Exit method false

    #

  end

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

  # * Update:  Acquire each Profile from the Animation Strip

  #     name  : used to identify the profile for possible editing

  #     index : index within the animation strip

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

  def update_profile_reader(name, index)

    #

    # Acquire the cached bitmap

    src_bitmap  = Cache.profiles(@msgprofile[index+4])

    # Possible edits to the bitmap may go here... before the returned bitmap

    return src_bitmap

    #

  end

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

  # * Convert Special Characters : Setting profile data name and message

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

  def convert_special_characters_profile

    #

    @text.gsub!(/\\[Aa][Bb]\[(.*?)\]/) do          # Substitute the \ab code

      $game_system.profile_name = $1              # ..and set the profile name

      ""

    end

    #

  end

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

  # * Terminate Message : Resetting of profile

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

  def terminate_message_profile

    #

    terminate_message_profile_erase               # Clear profile image

    $game_system.profile_hold = false             # Clear profile hold flag

    #

  end

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

  # * Terminate Message : Erasing of profile image and data

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

  def terminate_message_profile_erase

    #

    return if $game_system.profile_hold           # Clear profile hold

    return if @profile.nil?                       # Exit if no profile sprite

    return if @profile.disposed?                  # Exit if no profile sprite

    @profile.visible = false                      # Make profile sprite hidden

    unless @profile.bitmap.nil?                   # Only if there is a bitmap

      @profile.bitmap.dispose                     # ..dispose of the bitmap

    end

    @profile.bitmap = nil                         # Nil out the profile bitmap

    @msgprofile = []                              # Clear the filename array

    $game_system.profile_name = nil               # Erase the profile name

    @profilerepeat            = true

    #

  end

end

Instructions

Within the main header page / configuration page

Compatibility

Designed to work with the default message system, but should be compliant with most that are structurally similar.

Terms and Conditions

Free to use, even in commercial projects. However, I will need some form of due credit.

KSingleItemShop ACE

Mon, 28 Apr 2025 01:58:59 +0000

KSingleItemShop ACE

by Kyonides

Introduction

Normally, you would open the store menu and buy n amount of potions or rings, etc.
What would happen if some items were so unique that you could not ever find more than a single potion or ring there?
This script lets you setup such a custom shop with ease!

Setup Steps:

Turn on a specific switch.
Set the shop's ID via a game variable.
Use a custom backdrop instead of a snapshot of the current map.
Add items to the list of goods as usual.

The scriptlet will take care of deactivating it after exiting the custom menu.

The Script

Code:
# * KSingleItemShop ACE * #

#   Scripter : Kyonides

#   v0.6.0 - 2025-04-27

# Create a special shop that only offers single items on its shelves.

# To keep them separate from normal shops, turn on a specific switch and set

# the shop's ID via a specific variable. The rest is taken care by the script.

# It also allows you to set a backdrop as well instead of the current map.

module KSingleItem

  SHOP_SWITCH = 10

  SHOP_ID_VAR = 10

  DEFAULT_BACKDROPS = ["Wood2", "Room2"]

  class Shop

    attr_accessor :goods

  end

end

class Game_Party

  alias :kyon_single_item_gm_pty_init :initialize

  def initialize

    kyon_single_item_gm_pty_init

    @single_shops = {}

  end

  def setup_single_shop(shop_id, new_goods)

    shop = @single_shops[shop_id] || KSingleItem::Shop.new

    shop.goods = new_goods

  end

  attr_reader :single_shops

end

class Game_Interpreter

  def command_302

    return if $game_party.in_battle

    goods = [@params]

    while next_event_code == 605

      @index += 1

      goods.push(@list[@index].parameters)

    end

    if $game_switches[KSingleItem::SHOP_SWITCH]

      SceneManager.call(SingleShopScene)

    else

      SceneManager.call(Scene_Shop)

    end

    SceneManager.scene.prepare(goods, @params[4])

    Fiber.yield

  end

end

class Window_ShopBuy

  alias :kyon_single_item_win_shopbuy_draw_item :draw_item

  attr_reader :shop_goods

  def initialize(x, y, height, shop_goods, stretch=nil)

    @stretch = stretch

    super(x, y, window_width, height)

    @shop_goods = shop_goods.dup

    @money = 0

    @no_item = RPG::Item.new

    @symbol_color = Color.new(255, 255, 80)

    @symbol = $data_system.currency_unit

    refresh

    select(0)

  end

  def window_width

    @stretch ? 384 : 304

  end

  def item

    @data[@index] || @no_item

  end

  def money=(money)

    @money = money

    refresh

  end

  def price(item)

    @price[item.id]

  end

  def enable?(item)

    item && price(item) <= @money && !$game_party.item_max?(item)

  end

  def set_goods(type, gid)

    case type

    when 0

      $data_items[gid]

    when 1

      $data_weapons[gid]

    when 2

      $data_armors[gid]

    end

  end

  def make_item_list

    @data = []

    @price = {}

    @shop_goods.each do |goods|

      item = set_goods(goods[0], goods[1])

      next unless item

      @data << item

      @price[item.id] = goods[2] == 0 ? item.price : goods[3]

    end

  end

  def draw_item_data(item, rx, ry, enabled=true, w=240)

    return unless item

    draw_icon(item.icon_index, 28, ry, enabled)

    change_color(normal_color, enabled)

    draw_text(56, ry, w - 56, 24, item.name)

    draw_text(w, ry, 100, 24, price(item), 2)

    change_color(@symbol_color, enabled)

    draw_text(w + 100, ry, 16, 24, @symbol, 2)

  end

  def draw_item(n)

    unless @stretch

      kyon_single_item_win_shopbuy_draw_item(n)

    else

      item = @data[n]

      rect = item_rect(n)

      draw_item_data(item, rect.x, rect.y, enable?(item))

    end

  end

  def delete_item

    @shop_goods.delete(@index)

    item = @data.delete(@index)

    @price.delete(item.id)

    create_contents

    draw_all_items

  end

end

class SingleShopScene < Scene_Shop

  def find_shop_id

    $game_variables[KSingleItem::SHOP_ID_VAR]

  end

  def prepare(goods, purchase_only)

    shop_id = find_shop_id

    shop = $game_party.single_shops[shop_id]

    @goods = shop ? shop.goods : goods

    @purchase_only = purchase_only

  end

  def start

    create_main_viewport

    create_background

    @actor = $game_party.menu_actor

    create_help_window

    create_gold_window

    create_command_window

    create_buy_window

    create_status_window

    create_category_window

    create_sell_window

  end

  def create_background

    drop1, drop2 = KSingleItem::DEFAULT_BACKDROPS

    @backdrops = [Sprite.new, Sprite.new]

    @backdrops[0].bitmap = Cache.battleback1(drop1)

    @backdrops[1].bitmap = Cache.battleback2(drop2)

  end

  def create_buy_window

    @buy_window = Window_ShopBuy.new(0, 252, 24 * 7, @goods, true)

    @buy_window.viewport = @viewport

    @buy_window.help_window = @help_window

    @buy_window.hide

    @buy_window.set_handler(:ok,     method(:on_buy_ok))

    @buy_window.set_handler(:cancel, method(:on_buy_cancel))

  end

  def create_status_window

    wx = @buy_window.width

    wy = @buy_window.y

    ww = Graphics.width - wx

    @status_window = Window_ShopStatus.new(wx, wy, ww, @buy_window.height)

    @status_window.viewport = @viewport

    @status_window.hide

    @buy_window.status_window = @status_window

  end

  def create_category_window

    @category_window = Window_ItemCategory.new

    @category_window.viewport = @viewport

    @category_window.help_window = @help_window

    @category_window.hide.deactivate

    @category_window.set_handler(:ok,     method(:on_category_ok))

    @category_window.set_handler(:cancel, method(:on_category_cancel))

  end

  def command_buy

    activate_buy_window

  end

  def command_sell

    @category_window.show.activate

    @sell_window.show

    @sell_window.unselect

    @sell_window.refresh

  end

  def on_buy_ok

    @item = @buy_window.item

    @buy_window.hide

    Sound.play_shop

    do_buy(1)

    @gold_window.refresh

    @status_window.refresh

    @buy_window.delete_item

  end

  def on_buy_cancel

    @command_window.activate

    @buy_window.hide

    @status_window.hide

    @status_window.item = nil

    @help_window.clear

  end

  def dispose_background

    @backdrops.each do |sprite|

      sprite.bitmap.dispose

      sprite.dispose

    end

  end

  def terminate

    super

    reset_single_shop

  end

  def reset_single_shop

    list = @buy_window.shop_goods

    return list.size == @goods.size

    shop_id = find_shop_id

    return if shop_id == 0

    $game_party.setup_single_shop(shop_id, @buy_window.shop_goods)

    $game_variables[KSingleItem::SHOP_ID_VAR] = 0

    $game_switches[KSingleItem::SHOP_SWITCH] = false

  end

end

Terms & Conditions

Free as in beer.
Mention me in your game credits.
That's it!