Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==============================================================================
- # Advanced Text System
- # Version: 3.0c
- # Author: modern algebra (rmrk.net)
- # Date: September 7, 2010
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Thanks:
- # *Zeriab* for his tutorial on RegExp, but most of all for being my mentor
- # and friend. Without him, this script, and all my other scripts, will
- # never have been made.
- # For ideas on improving this script through bug reports or suggestions:
- # Arrow-1, Irock, Stonewall, PhantomH, Seasons in the Abyss, Aindra, Arion,
- # Okogawa, Megatronx, Charbel, Adrien., dricc, Raukue, EricDahRed, redyugi,
- # HeartofShadow, Woratana, tsy0302, Kayo, deadnub.
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Description:
- #
- # This scripts adds a whole bunch of features to message boxes, making them
- # much prettier and with a lot more functionality than the default. What and
- # how to use each feature will be exhaustively detailed in the instructions,
- # but for now I will just give a list of a few of the staple features:
- #
- # ~Appended Text~
- # A staple feature of ATS, this will combine the messages of subsequent text
- # events (that share properties). It is useful particularly when combined
- # with text scrolling.
- #
- # ~Text Scrolling~
- # This feature allows longer text messages to scroll upwards, so that for
- # longer messages, the contents of the window will scroll upwards when it
- # reaches the bottom, allowing the player to read what has come before and
- # ignore the annoying new page requirements. This feature has been beefed up
- # in ATS 3.0, with the scroll now being much smoother and the speed user-
- # definable, in addition to the new feature of Scroll Review, which, once the
- # message is finished, allows the player to scroll upwards to see any text he
- # or she might have missed. Moreover, you can also scroll by page instead.
- #
- # ~Paragraph Format~
- # Always a staple feature in the ATS, turning this feature on allows you to
- # avoid the hassle that comes with making the text fit within the window by
- # analyzing the exact length with reference to the grey arrows. Now you can
- # type freely and know that nothing will get cut off. This feature takes on
- # additional importance in ATS 3.0 with the addition of a special message
- # codes like \S[] and \S![], more on which will be discussed later. As
- # always, you can still manually define line breaks with the \LB code. As in
- # previous versions, you can also justify text, meaning that the letters will
- # be spaced out so as to exactly cover the width of the message box. Unlike
- # previous versions, this paragraph formatter is integrated with the ATS in
- # order to better accomodate text features and therefore does not require a
- # separate Paragraph Formatter script to work.
- #
- # ~Advanced Choices~
- # Another staple feature of the ATS, you have been able to append choices
- # from subsequent choice branches and show them all in a separate window.
- # This feature has been vastly expanded on in ATS 3.0. In earlier versions,
- # many of the features respecting advanced choices, such as appending them
- # and tying choices to switches, were available only if using the choice
- # window. In ATS 3.0, these features have been included in the traditional
- # in-message window. Don't want to use the choice window but do want to
- # exclude some choices unless a particular switch is ON? You can do that now.
- # In addition to all of the old features, there are quite a few new ones that
- # will make your choices more dynamic. One is the ability to make an the
- # cursor pass over an option. This means it is a perfect way to include
- # headings or blank spaces in your choice box. Another new feature are the
- # disable codes which allow you to make a choice unselectable, so when the
- # player tries to select it the buzzer sound is played and nothing happens.
- # Further, there is an external message property that can be set which you
- # can use to automatically add certain properties to modify the choice text
- # if it is disabled, such as a command to reduce the opacity of it. In
- # addition, you can automatically modify all choice texts at once - want to
- # add a larger indent or make all choices blue - you can do that. Finally,
- # another unique feature of ATS choices is the \+{} code. Placed in a comment
- # directly below a when branch of a choice branch, this allows you to add
- # whatever text you want to that choice, effectively ignoring the limitations
- # on choice message size. This means you can make your choices sentences
- # instead of simple yes or nos. In addition to this, another new feature of
- # ATS 3.0 choices is that choice messages can be longer than one line and
- # that is recognized both in the choicebox and the new and improved default
- # choice scheme. The last new feature added to choices in ATS 3.0 is the
- # ability to set a help window for it. This means it will set a window whose
- # contents will change depending on which choice the player is hovering over.
- #
- # ~Advanced Faces~
- # From the very start, animated faces have been a part of the ATS. This
- # feature allows you to have the faces animate for every few letters drawn -
- # perfect to make it look like the face is talking. However, this is not all
- # the special features you gain with faces. As always, you can also use much
- # larger or smaller faces, mirror them, set them to the right side of the
- # text box, or move them anywhere you like, change the opacity, or surround
- # it with a window. New in ATS 3.0, you can now define the exact size of the
- # border of the window if using it, or you can use another sprite for it
- # (just like the dim background of the Message Window). Also new in ATS 3.0,
- # you can scroll the face in when it first appears either horizontally or
- # vertically, or fade it in. You can also choose to make the face appear over
- # or under the message window, and change the blend type.
- #
- # ~Letter Control~
- # This has always been a feature of the ATS and it allows you to control the
- # speed that text is drawn, as well as putting in pauses at will. It also
- # allows you to specify a sound, and you can even have it vary the pitch with
- # every letter so that it mimics the sound of a voice. New in ATS 3.0, you
- # can control the speed text is drawn not only through the \> and \< codes,
- # but more directly via the \S[] command, where you can either set it to add
- # or subtract a number from the current speed, or you can set it directly.
- # See the section on this code in Special Message Codes for details.
- #
- # ~Advanced Message Window~
- # There are also a number of special features related to the appearance and
- # position of the message window. Most of these should be familiar to users
- # of ATS 2.0. You can manually control the size and exact position of the
- # text box, or you can set it to automatic. Further, you can use the
- # :fit_window_to_text property to set the width of the window to be only as
- # long as it needs to be to accomodate the longest line. As always, you can
- # set what windowskin to use, the font, how much space for each line, and the
- # dim background. New features include the :do_not_obscure property, which,
- # when using default positioning, will ensure that the characters specified
- # in the :obscure_characters array. This feature will be ignored if manually
- # setting position however. The only thing it does is, if you have the
- # position set to bottom, but that would cover the player and you include the
- # player in your obscure_characters array, then it would move the message box
- # to the top instead. As always, you can use \OC[], \UC[], \LC[], and \RC[]
- # to position the window in reference to a character. Something new is the
- # \E[] command, which will set it above the character, unless there is not
- # enough room, in which case it sets it below the character. Another new
- # feature is speech tags, which, when using \OC[], \UC[], or \E[] codes will
- # place a tag from the character speaking to the message window if this
- # feature is enabled.
- #
- # ~Word Boxes~
- # New to ATS 3.0, this is a very simple feature that works akin to the Gold
- # or Name window. Basically, it allows you to set a one line message to
- # appear instantly. It can be used, for instance, if you want to show the
- # value of a variable in the corner while showing this message or choice.
- # Naturally, name boxes have also been retained from ATS 2.0
- #
- # ~Graphic Novel Support~
- # New to ATS 3.0, this feature, when activated, allows the player to
- # completely hide and prevent from updating every message related window for
- # as long as the player holds a button you choose or, if you wish, it can be
- # a toggle rather than a press. It is useful if you have a game that relies
- # heavily on graphics and you want to give the player the opportunity to just
- # look at the background, like in many graphic novel games.
- #
- # ~Move While Showing~
- # Also new to ATS 3.0, this is a feature that, when activated, allows the
- # player to move around while a message is showing. However, when a choice
- # selection is active, this feature will be disabled.
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Instructions:
- #
- # Place this script in its own slot in the Script Editor (F11) above Main
- # and below Materials. This script is not compatible with most other message
- # systems, so you may need to remove any other message systems. If you are
- # upgrading to this from ATS 2.0, you will need to also install the
- # conversion patch, located in this script's thread at RMRK.
- #
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # ~Special Message Codes~
- # These codes work in all ATS windows.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # You will recognize many of these from previous versions of the ATS. A lot
- # are new though.
- # \lb - Line break. Go to next line.
- # \v[x] - Draw the value of the variable with ID x.
- # \n[x] - Draw the name of the actor with ID x.
- # \c[x] - Set the colour of the text being drawn to the xth colour of the
- # Windowskin palette. 0 is the normal color and 16 is the system color.
- # \c[#RRGGBB] - Set the colour of the text being drawn to any colour, using
- # hexadecimal. You can set each colour (red, green, blue) to anything
- # from 0-255 (00-FF). You must use hexadecimal values.
- # \p[x] OR \pid[x] - Draw the ID of the actor in the xth position in the party.
- # \ni[x] - Draw the name of the item with ID x.
- # \nw[x] - Draw the name of the weapon with ID x.
- # \na[x] - Draw the name of the armor with ID x.
- # \ns[x] - Draw the name of the skill with ID x.
- # \nt[x] - Draw the name of the state with ID x.
- # \nc[x] - Draw the name of the class with ID x.
- # \ne[x] - Draw the name of the event with ID x on the current map.
- # \nm[x] - Draw the name of the enemy with ID x.
- # \nl[x] - Draw the name of the element with ID x.
- # \nv[x] - Draw the name of the variable with ID x.
- # \nsw[x] - Draw the name of the switch with ID x.
- # \np[x] - Draw the name of the actor in the nth position in the party.
- # \map - Draw the name of the map the player is currently on.
- # \map[x] - Draw the name of the map with ID x.
- # \di[x] - Draw the description of the item with ID x.
- # \dw[x] - Draw the description of the weapon with ID x.
- # \da[x] - Draw the description of the armor with ID x.
- # \ds[x] - Draw the description of the skill with ID x.
- # \pi[x] - Draw the price of the item with ID x.
- # \pw[x] - Draw the price of the weapon with ID x.
- # \pa[x] - Draw the price of the armor with ID x.
- # \i#[x] - Draw the number of the item with ID x that the party posesses.
- # \w#[x] - Draw the number of the weapon with ID x that the party posesses.
- # \a#[x] - Draw the number of the armor with ID x that the party posesses.
- # \ac[x] - Draw the class of the actor with ID x.
- # \i[x] - Draw the icon with index x.
- # \ii[x] - Draw the icon of the item with ID x.
- # \wi[x] - Draw the icon of the weapon with ID x.
- # \ai[x] - Draw the icon of the armor with ID x.
- # \si[x] - Draw the icon of the skill with ID x.
- # \ti[x] - Draw the icon of the state with ID x.
- # \fn[fontname] - Change the font to fontname
- # \fs[x] - Change the fontsize to x.
- # \fa[x] - Change the alpha value (opacity) of the font to x.
- # \b - Turn bold on. Text drawn after this code will be bolded.
- # /b - Turn bold off.
- # \i - Turn italic on. Text drawn after this code will be italicized.
- # /i - Turn italic off.
- # \s - Turn shadow on. Text drawn after this code will have a shadow.
- # /s - Turn shadow off.
- # \u - Turn underline on. Text drawn after this code will be underlined.
- # /u - Turn underline off.
- # \hl[x] - Turn highlight on. Text drawn after this code will be highlighted
- # with colour x from the windowskin palette
- # /hl OR \hl[-1] - Turn highlight off.
- # \l - align the text to the left
- # \r - align the text to the right
- # \c - align the text to the centre.
- # \t - Tab. Draws the next character at the nearest pixel that is a
- # multiple of 32. Doesn't work well with the :justified_text property.
- # \x[n] - Sets the x position for drawing directly to n.
- # \f[key] - Draw the value corresponding to that key in the FILTERS array. If
- # the key has quotation marks around it, you need to put "key"
- # \s[x,text] - Will only draw text if the switch with ID x is ON.
- # \s![x,text] - Will only draw text if the switch with ID x is OFF.
- # \vocab[method] - Will draw whatever Vocab.method returns, if it is a valid
- # method call. Suitable values for method are: level, level_a, hp,
- # hp_a, mp, mp_a, atk, def, spi, agi, weapon, armor1, armor2, armor3,
- # armor4, weapon1, weapon2, attack, skill, guard, item, equip, status,
- # save, game_end, fight, escape, new_game, shutdown, to_title, gold,
- # continue, cancel
- # \actor_method[x] - This will draw whatever actor.method returns for whoever
- # actor x. Some suitable values for method are: atk, def, spi, agi,
- # level, exp, name, hp, maxhp, mp, maxmp, & any other methods that
- # return values from Game_Actor.
- # \i_method[x] - This will draw whatever item.method returns for the item with
- # ID x. Some suitable values for method are: name, description,
- # base_damage, variance, atk_f, spi_f, price, hp_recovery_rate,
- # hp_recovery, mp_recovery_rate, mp_recovery, parameter_points, note,
- # n, & any other methods that return values from RPG::Item. Also, note
- # will return all of the contents of the note field, whereas n will
- # only return notefield text located between a \msg[text]msg/ code.
- # \w_method[x] - This will draw whatever weapon.method returns for the weapon
- # with ID x. Some suitable values for method are: name, description,
- # price, hit, atk, def, spi, agi, note, n, & any other methods that
- # return values from RPG::Weapon. Also, note will return all
- # of the contents of the note field, whereas n will only return
- # notefield text located between a \msg[text]msg/ code.
- # \a_method[x] - This will draw whatever armor.method returns for the armor
- # with ID x. Some suitable values for method are: name, description,
- # price, eva, atk, def, spi, agi, note, n, & any other methods that
- # return values from RPG::Armor. Also, note will return all
- # of the contents of the note field, whereas n will only return
- # notefield text located between a \msg[text]msg/ code.
- # \s_method[x] - This will draw whatever skill.method returns for the skill
- # with ID x. Some suitable values for method are: name, description,
- # base_damage, variance, atk_f, spi_f, hit, mp_cost, note, n, & any
- # other methods that return values from RPG::Weapon. Also, note will
- # return all of the contents of the note field, whereas n will only
- # return notefield text located between a \msg[text]msg/ code.
- # \t_method[x] - This will draw whatever state.method returns for the state
- # with ID x. Some suitable values for method are: name, atk_rate,
- # def_rate, spi_rate, agi_rate, message1, message2, message3,
- # message4, note, n, & any other methods that return values from
- # RPG::State. Also, note will return all of the contents of the note
- # field, whereas n will only return notefield text located between a
- # \msg[text]msg/ code.
- # \enemy_method[x] - This will draw whatever enemy.method returns for whoever
- # the enemy with ID x is. Some suitable values for method are: name,
- # atk, def, spi, agi, hit, eva, exp, gold, note, n, & any other
- # methods that return values from RPG::Enemy. Also, note will return
- # all of the contents of the note field, whereas n will only return
- # text located between a \msg[text]msg/ code.
- # \#{code}# - This will evaluate code. So, if you know scipting, you can place
- # any code there and it will draw whatever is returned by it. For
- # instance: \#{$game_system.save_count}# would draw the number of
- # times the player has saved the current game.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # ~Message Box specific codes~
- # These codes will only work in the Message Window.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # \g - Shows a window with the party's gold. Closes if already open
- # \nb[name] - Shows a name box with name displayed in the box
- # /nb - Closes the namebox
- # \wb[word] - shows the word in its own window, similar to the gold window.
- # /wb - Closes a wordbox
- # \. - Wait 15 frames (1/4 second) before drawing the next letter.
- # \| - Wait 60 frames (1 second) before drawing the next letter.
- # \w[x] - Wait x frames before drawing the next letter.
- # \! - Pause. Make the message wait for player input before continuing.
- # \^ - Skip the next pause without waiting for player input.
- # \> - Speed up the text drawing by reducing wait time between letters by
- # one frame.
- # \< - Slow down the text drawing by increasing wait time between letters by
- # one frame.
- # \S[x] - Change the speed the text draws by adding x to the current time
- # between drawing letters. Thus, \s[2] is the equivalent of \<\< and
- # \s[-3] is the equivalent of \>\>\>. You can also directly set the
- # speed by putting an equal sign, so \s[=0] would set the time to one
- # frame between drawing letters, and \s[=-1] would set it to instant.
- # \@ - Turn on Show line fast - the line up to /@ will be shown instantly
- # /@ - Turn off Show line fast.
- # \@@ - Turn on Show message fast. This will show the entire message
- # instantly, at least until the next scroll or it hits a /@@
- # /@@ - Turn off Show message fast.
- # \% - Disable Text Skip through user input
- # \se[sound effect name] - Plays a sound effect
- # \me[music effect name] - Plays a musical effect
- # \ani[target_id,animation_id] - Shows animation_id on target_id. 0 => player,
- # other numbers indicate the ID of the event
- # \bln[target_id,balloon_id] - Same as ani, but shows a balloon
- # \af[x] - Show the face of the actor with ID x.
- # \pb - Page Break. Clear the contents and start drawing from the first line
- # \oc[x] - positions the message box over a character. 0 => player; when >1, it
- # will show over the event with that ID on the map.
- # \uc[x] - same as \oc, but places box under character
- # \lc[x] - same as \oc, but places box to left of character
- # \rc[x] - same as \oc, but places box to right of character
- # \e[x] - same as \oc, but if the box is too tall to comfortably fit, is moved
- # below the character instead.
- # \mxy[x, y] - Set the position of the message window to x, y.
- # \fxy[x, y] - Set the position of the face window to x, y.
- # \nxy[x, y] - Set the position of the name window to x, y.
- # \#!{code}# - This will evaluate code at the time the window reaches this code
- # when drawing. It does not put the result of the code into the message
- # but is instead intended to be evaluated. For instance: \#!{new_page}#
- # would perform the same function as \pb. You need to know syntax!
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # ~Choice Branch Specific Codes~
- # These codes only work in choice branches.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # \skip - Placing this in a choice text means that the player will not be able
- # to hover over or select this option, but will skip to the next one.
- # Perfect for making subheadings for your choices, or blank spaces.
- # \soff[x] - A choice with this in it will only appear in the branch if the
- # switch with ID x is OFF.
- # \son[x] - Same as soff[x], but it will only appear if switch x is ON.
- # \d[x] - A choice with this in it will be disabled (unselectable) if the
- # switch with ID x is OFF. It will still show up, and the player can
- # hover over it, but he or she will be prevented from selecting it.
- # \d![x] - Same as \d[x], except it will be disabled if switch x is ON.
- # \wb[text] - This code will create a help window. When the player hovers over
- # that choice, it will show text in the help window. This allows you to
- # explain the choice or make any content in the help window dependent
- # on which choice the player is on.
- # \+{text} - This is actually a code you can put in a comment that is directly
- # below the when branch of a choice, and it will add text to the
- # choice. This effectively ignores the normal limitations on the size
- # of a message in a choice, allowing you to make longer texts for
- # choices.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # ~Message Properties~
- # The following are properties of the message window that are set prior to
- # calling the message and govern many properties. You set the default values
- # to the constants of the same name in Game_ATS, starting at line 766. Those
- # will be the values that each game starts out with. You can then change them
- # on a message to message basis through either of the codes:
- # ats_next (:property, new_value)
- # or:
- # $game_message.property = new_value
- # However, it will reset to the default after the next message is processed.
- # If you want to change it on a permanent basis, you have to use either:
- # ats_all (:property, new_value)
- # or:
- # $game_ats.property = new_value
- # $game_message.property = new_value
- #
- # All of the properties and what types of values are expected for each are
- # listed below. Note that if you use the ats_next or ats_all commands, you
- # have to retain the : in front of the name. If you use the $game_ats or
- # $game_message route then you don't use the :
- #
- # You can reset $game_ats to the constants with: $game_ats.reset
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :max_lines - This is the maximum number of lines to show at a time before
- # either going to a new page or scrolling. Default: 4
- # :message_speed - This is the number of frames to wait in between drawing
- # letters. -1 is instant. 0 is 1 frame. Default: 0
- # :skip_disabled - Whether the player can speed text up by pressing ENTER.
- # :append_text - Whether to include all text from subsequent text commands in
- # the next message. true => append; false => do not append. Default: true
- # :append_choice - Whether to include all choices from subsequent choice
- # choice branches in the next choice selection. The cancel branch is
- # inherited from the last branch to not have cancel disabled.
- # true => append; false => do not append. Default: true
- # :scrolling - Whether to scroll once :max_lines is exceeded or to pause and
- # start a new page. true => scroll; false => new page. Default: true
- # :scroll_speed - If :scrolling is true, this is how many pixels it moves per
- # frame when scrolling text. Default: 2
- # :scroll_show_arrows - If :scrolling is true, this determines whether or not
- # to show the arrows when the contents grow. true => show; false => do
- # not show. Default: true
- # :scroll_autopause - If :scrolling is true, this determines whether or not to
- # insert a pause before it scrolls to the next line. Default: false
- # :scroll_review - If :scrolling is true, this option is whether or not the
- # player has the option to review the message that has just finished by
- # pressing up and down. true => yes; false => no. Default: true
- # :scroll_by_page - Whether to scroll by whole page or by line. Default: false
- # :paragraph_format - When this is true, the manual line breaks are ignored and
- # it will draw as many characters as will fit on each line. You can still
- # force a line break with the \lb code though. Default: false
- # :justified_text - If :paragraph_format is true, then this option will make
- # the spacing of a line exactly such that it takes up the entire width of
- # the message window. Default: false
- # :letter_sound - When this is true, a sound will be played upon drawing
- # letters. Default: false
- # :letter_se - If :letter_sound is true, this is the SE that is played. It is
- # set in the format ["filename", volume, pitch]. Default: ["Open1", 40]
- # :letters_per_se - If :letter_sound is true, this is the frequency that the
- # SE is played. The SE will play every time this number of letters is
- # drawn. Default: 3
- # :random_pitch - If :letter_sound is true, this is the range the pitch of the
- # SE will vary within. It can be used to mimic the pitch variations of
- # a human voice. It is a range in the format x..y. If x is equal to y,
- # then the pitch won't vary. If set to an integer, it will take that as
- # the variance from the regular pitch of the SE. Default: 100..100
- # :speech_tag_index - This refers to which speech tag to use when showing a
- # message window above or below an event or player. -1 => no tag, while
- # anything greater refers to the graphic of the corresponding index in
- # :speech_tag_graphics. Default: -1
- # :speech_tag_graphics - This is an array containing the names of all speech
- # tag graphics in the System folder of Graphics. Which one is used when
- # showing a message depends on the value of :speech_tag_index.
- # Default: ["Speech Tag 1", "Speech Tag 2", "Thought Tag 1"]
- # :start_sound - If true, a sound will be played when a message starts.
- # Default: false
- # :start_se - If :start_sound is true, this is the SE that is played. It is
- # set in the format ["filename", volume, pitch]. Default: ["Chime2"]
- # :finish_sound - If true, a sound will be played when a message finishes.
- # Default: false
- # :finish_se - If :finish_sound is true, this is the SE that is played. It is
- # set in the format ["filename", volume, pitch]. Default: ["Chime1"]
- # :pause_sound - If true, a sound will be played when a message pauses.
- # Default: false
- # :pause_se - If :pause_sound is true, this is the SE that is played. It is
- # set in the format ["filename", volume, pitch]. Default: ["Decision2"]
- # :terminate_sound - If true, a sound will be played when a message closes.
- # Default: false
- # :terminate_se - If :terminate_sound is true, this is the SE that is played. It is
- # set in the format ["filename", volume, pitch]. Default: ["Cancel"]
- # :move_when_visible - When this is true, the player will still be able to move
- # when the message window is displaying text. It is recommended that you
- # turn scroll review off when using this feature though, as it looks
- # dumb. Also, whenever a choice starts, it takes precedence and the
- # player will not be able to move even if this is true. Default: false
- # :graphic_novel - When this is true, it means the player can press the
- # :hide_button and everything relating to the message window becomes
- # invisible and stops updating until the player releases the button. It
- # is intended for use where a player might want to see the whole screen
- # and not have things hidden by the ATS windows. Default: false
- # :hide_button - If :graphic_novel is true, this is the button that hides the
- # ATS windows when pressed. Default: Input::F5
- # :gn_press_or_toggle - If :graphic_novel is true, this determines whether the
- # player has to hold down the :hide_button or whether it acts as a toggle.
- # true => press; false => toggle. Default: true
- # :filters - This is a hash holding user-defined replacements for special
- # codes. This is the hash that is accessed when using the \f[x] message
- # code and is useful, for instance, if you have a character choose their
- # sex at the start of the game. Then you can set the filters to the
- # appropriate pronoun and use that and not have to have separate text
- # boxes just to differentiate between when people say he or her.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :message_x - This is the x coordinate of the message window. If it is set to
- # -1, then it will be centred. If not, it will be directly set to that
- # coordinate of the screen. Default: -1
- # :message_y - This is the y coordinate of the message window. If it is set to
- # -1, then it will abide by the normal way of setting position through
- # the top, middle, bottom option in the text window. If it is not -1,
- # then it will be directly set to that coordinate. Default: -1
- # :wlh - the line height of lines in the message window. Default: 24
- # :battle_wlh - the line height of lines in the message window during battle.
- # This should always be 24 unless you have a good reason. Default: 24
- # :do_not_obscure - When using default positioning, this will choose a
- # different position setting if the current one is over any of the
- # characters included in :obscure_characters
- # :obscure_characters - If :do_not_obscure is true and the message is being set
- # using default positioning, then the message box will be choose override
- # the chosen position if the chosen position obscures one or more of the
- # characters in this array and another position would obscure less. The
- # player is identified by 0 and any number greater than that refers to
- # the event with that ID. When setting up the default, it is recommended
- # that you only include the player and set others only on a map by map
- # basis. Default: [0]
- # :obscure_buffer - this is how much space from the bottom of the character you
- # want to avoid obscuring. It should be set to the height of the tallest
- # character you want to avoid obscuring. Default: 32
- # :fit_window_to_text - If this is true, then the window will be made to be
- # just wide enough to contain the longest line and just tall enough to
- # contain either all the lines up to :max_lines. Default: false
- # :message_width - This is how many pixels wide the message window is.
- # Default: 544
- # :message_height - This is how many pixels tall the message window is.
- # Default: 128
- # :message_opacity - This is the opacity of the window. Default: 255
- # :message_backopacity - This is the opacity of the background of the
- # windowskin. Default: 200
- # :message_windowskin - This is the windowskin that this window uses. It must
- # be a graphic located in the System folder. Default: "Window"
- # :message_fontcolour - This is the default colour of the font that is used
- # everytime a new page is made. It can either refer to the windowskin
- # palette (0-31) or be [red, green, blue] array. Default: 0
- # :message_fontname - This is the default font of the window. It can either
- # refer to a single font or to a prioritized array of fonts, where the
- # first one is used unless that font is not installed, and so on.
- # Default: ["Verdana", "Arial", "Courier New"]
- # :message_fontsize - This is the default size of the font. Default: 20
- # :message_fontalpha - This is the default opacity of the text. Default: 255
- # :message_dim - The graphic to use when selecting the "Dim" option.
- # Default: "MessageBack"
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :face_x - The x coordinate of the face box. If set to -1, the x-coordinate
- # will be automatically positioned. If not, it will be directly set to
- # this value. Default: -1
- # :face_y - The y coordinate of the face box. If set to -1, the y-coordinate
- # will be automatically positioned. If not, it will be directly set to
- # this value. Default: -1
- # :face_z - If this is >0, it will show up above the message window. If less
- # than 0, it will show up below the message window. Default: 10
- # :face_side - When :face_x is -1, this determines which side of the message
- # box the face shows up on. true => Left; false => Right. Default: true
- # :face_offset_x - When :choice_x is -1, this is added to the x position.
- # Default: 0
- # :face_offset_y - When :choice_y is -1, this is added to the y position.
- # Default: 0
- # :face_width - This determines the width of the face. When 0, it will show the
- # whole width of the face, even if using single face graphics. If you want
- # to show only a portion of the face, then set it directly. Default: 0
- # :face_height - This determines the height of the face. When 0, it will show
- # the whole height of the face, even if using single face graphics. If
- # you want to show only part of the face, then set it directly. Default: 0
- # :face_mirror - When true, the face will be drawn mirrored. Default: false
- # :face_opacity - This is the opacity of the face. Default: 255
- # :face_blend_type - This is the blend type of the face sprites. 0 => normal;
- # 1 => addition; 2 => subtraction. Default: 0
- # :face_fadein - When this is true, the face will fadein when starting a
- # message instead of just automatically appearing. Default: false
- # :face_fade_speed - If :face_fadein is true, this is how much the opacity will
- # change every frame. Default: 10
- # :face_scroll_x - Option to scroll the face in horizontally. Default: false
- # :face_scroll_y - Option to scroll the face in vertically. Default: false
- # :face_scroll_speed - If either :face_scroll_x or :face_scroll_y are true,
- # this is the number of pixels per frame it scrolls in at.
- # :animate_faces - When this is true, specially labelled face files will
- # animate. Face files that have ![x] in the name will take the first x
- # faces in the file and animate between them. Alternatively, it can take
- # the face of the same index from separate face files that are sequenced
- # by suffixes _1, _2, etc... Default: true
- # :letters_per_face - when :animate_faces is true, this is how many letters to
- # draw between rotating the faces.
- # :face_window - If true, the face will be framed by a window. Default: false
- # :face_window_opacity - If :face_window is true, this is the opacity of that
- # window. Default: 255
- # :face_windowskin - If :face_window is true, this is the windowskin it uses.
- # Default: "Window"
- # :face_border_size - If :face_window is true, this is the size of the border.
- # Default: 6
- # :face_dim - If using :face_window and dim, the sprite to stretch as a
- # background for the face. Default: "MessageBack"
- # :face_use_dim - The setting for using dim. If 0, it will never use dim. If 1,
- # it will use the dim sprite if :face_window is true. If 2, it will use
- # dim only when the message window is also using dim. Default: 0
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :choice_text - This is a bracket for any choice text. It is useful if, for
- # instance, you want particular codes to apply to every choice in a
- # branch. You must include %s in the string, and that is where the actual
- # choice text will show up, bracketed by whatever other codes you put in
- # Default: " %s" (meaning every choice will be indented by four spaces)
- # :disabled_choice_text - Same as above, except it only applies to choices that
- # are disabled and is applied after :choice_text is. It is useful if you
- # want to differentiate between disabled choices and non-disabled ones.
- # Unlike :choice_text, %s doesn't have to be included and in that case all
- # disabled choices would simply be replaced by this text.
- # Default: "\\FA[128]%s\\FA[255]" (meaning disabled choices will be drawn
- # at 128 opacity).
- # :choicebox_text - The same as :choice_text, but this is what is applied when
- # using a choicebox instead of :choice_text. Default: "%s" (no change)
- # :choice_window - Whether or not choices will show up in a separate window.
- # Default: false
- # :choice_x - The x coordinate of the choice window. When this is -1, the x
- # position will be set automatically in reference to the position of the
- # message window (end of the side opposite the face). When anything else,
- # the x position is directly set to that coordinate. Default: -1
- # :choice_y - The y coordinate of the choice window. Whwn this is -1, the y
- # position is set automatically directly above the message window or
- # below, if it goes off screen when placed above. Default: -1
- # :choice_offset_x - When :choice_x is -1, this is added to the auto x position.
- # Default: -16
- # :choice_offset_y - When :choice_y is -1, this is added to the auto y position.
- # Default: 16
- # :choice_width - This is the width of the choice window. When -1, it will set
- # it to as wide as necessary to accomodate the longest line, up to a
- # maximum of the screen width. Default: 192
- # :choice_height - This is the height of the choice window. When -1, it is set
- # to the number of rows necessary to draw all choices, up to :max_lines.
- # :column_max - When using :choice_window, the number of columns. Default: 1
- # :row_max - When :choice_height is -1, the max number of rows. Default: 4
- # :choice_spacing - When :column_max > 1, this is how much empty space is left
- # between options on the same row. Default: 20
- # :choice_opacity - This is the opacity of the choice window. Default: 255
- # :choice_backopacity - This is the opacity of the background of the choice
- # window. Default: 200
- # :choice_windowskin - This is the name of the System file to use as the
- # windowskin for the choice window. Default: "Window"
- # :choice_fontcolour - The default colour of text in the choice window. It can
- # be from the windowskin palette or a [red, green, blue] array. Default: 0
- # :choice_fontname - The font for the choice window. If an array, it will take
- # the first font in the array that the player has installed.
- # Default: ["Verdana", "Arial", "Courier New"]
- # :choice_fontsize - Default size of the font in the choice window. Default: 20
- # :choice_wlh - The vertical space of each row of the choice window. Default: 24
- # :choice_dim - If using :choice_window and dim, the sprite to stretch as a
- # background for the choice branch. Default: "MessageBack"
- # :choice_use_dim - The setting for using dim. If 0, it will never use dim. If
- # 1, it will use the dim sprite if :choice_window is true. If 2, it will
- # use dim only when the message window is also using dim. Default: 2
- # :choice_on_line - Whether to show the choice box adjacent to the message
- # window or not. Doesn't apply if :choice_width is not directly set or if
- # :fit_window_to_text is on and larger than :choice_width. Default: false
- # :choice_opposite_face - When true, the side the choice is shown on is the
- # opposite side the face is on. And vice versa. Default: true
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :choicehelp_x - The x coordinate of the choicehelp window. When this is -1,
- # the x position is centred. Default: -1
- # :choicehelp_y - The y coordinate of the choicehelp window. Whwn this is -1,
- # the y position is at the top of the screen unless it overlaps with the
- # message window, in which case it goes to the bottom. Default: -1
- # :choicehelp_width - This is the width of the choicehelp window. When -1, it
- # will set it to the width of the longest line, up to a maximum of the
- # screen width. Default: -1
- # :choicehelp_height - This is the height of the choicehelp window. When -1, it
- # is set to accomodate the greatest number of lines that any choice option
- # requires: Default: -1
- # :choicehelp_center - Whether or not to centre the text vertically when the
- # number of lines is smaller than the height of the window. Default: true
- # :choicehelp_opacity - This is the opacity of the choicehelp window.
- # Default: 255
- # :choicehelp_backopacity - This is the opacity of the background of the
- # choicehelp window. Default: 200
- # :choicehelp_windowskin - This is the name of the System file to use as the
- # windowskin for the choicehelp window. Default: "Window"
- # :choicehelp_fontcolour - This is the default colour of text in the choicehelp
- # window. It can either be from the windowskin palette or a
- # [red, green, blue, alpha] array. Default: 0
- # :choicehelp_fontname - This is either a string or array containing the name
- # of the font used in the choicehelp window. If an array, it will take
- # the first font in the array that the player has installed.
- # Default: ["Verdana", "Arial", "Courier New"]
- # :choicehelp_fontsize - This is the default size of the font in the choicehelp
- # window. Default: 20
- # :choicehelp_wlh - This is the vertical space required for each line of the
- # choicehelp window. Default: 24
- # :choicehelp_dim - If using :choicehelp_window and dim, the sprite to stretch
- # as a background for the choicehelp branch. Default: "MessageBack"
- # :choicehelp_use_dim - The setting for using dim. If 0, it will never use dim.
- # If 1, it will use the dim sprite if :choicehelp_window is true. If 2,
- # it will use dim only when the message window is also using dim.
- # Default: 2
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :name_x - The x coordinate of the name window. When this is -1, the x
- # coordinate is automatically placed on the same side the face would be
- # if automatically positioned. Default: -1
- # :name_y - The y coordinate of the name window. When this is -1, the y
- # coordinate is just above the message window, unless it goes off the
- # screen, in which case it is placed just below. Default: -1
- # :name_offset_x - When :name_x is -1, this is added to the x position.
- # Default: 16
- # :name_offset_y - When :name_y is -1, this is added to the y position.
- # Default: 16
- # :name_opacity - This is the opacity of the name window. Default: 255
- # :name_backopacity - This is the opacity of the background of the name window.
- # Default: 200
- # :name_windowskin - This is the name of the System file to use as the
- # windowskin for the name window. Default: "Window"
- # :name_border_size - The size of the windowskin border around the name.
- # Default: 8
- # :name_wlh - This is the vertical space required for each line of the name
- # window. Default: 24
- # :name_fontcolour - This is the default colour of text in the name window. It
- # can either be from the windowskin palette or a [red, green, blue]
- # array. Default: 0
- # :name_fontname - This is either a string or array containing the name of the
- # font used in the name window. If an array, it will take the first font
- # in the array that the player has installed.
- # Default: ["Verdana", "Arial", "Courier New"]
- # :name_fontsize - This is the default size of the font in the name window.
- # Default: 20
- # :name_dim - If using dim, the sprite to stretch as a background for the name
- # box. Default: "MessageBack"
- # :name_use_dim - The setting for using dim. If 0, it will never use dim.
- # If 1, it will use the dim sprite. If 2, it will use dim only when the
- # message window is also using dim. Default: 2
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :word_x - The x coordinate of the word window. When this is -1, the word
- # window is centred, or to the left of the gold window if the gold window
- # is visible and :word_y is -1. If not -1, it is directly set to that
- # coordinate. Default: -1
- # :word_y - The y coordinate of the word window. When this is -1, the y
- # coordinate is at the same position as the gold window, unless the gold
- # window is visible and the word window is too wide to fit to the left of
- # it, in which case it is directly above or below the gold window,
- # depending on where it fits. If not -1, it is directly set to that
- # coordinate. Default: -1
- # :word_width - The width of the word window. When -1, it is set to accomodate
- # the longest line. Default: 160
- # :word_height - The height of the word window. When -1, it will be set to
- # accomodate the number of lines. Default: -1
- # :word_opacity - This is the opacity of the word window. Default: 255
- # :word_backopacity - This is the opacity of the background of the word window.
- # Default: 200
- # :word_windowskin - This is the word of the System file to use as the
- # windowskin for the word window. Default: "Window"
- # :word_wlh - This is the vertical space required for each line of the word
- # window. Default: 24
- # :word_fontcolour - This is the default colour of text in the word window. It
- # can either be from the windowskin palette or a [red, green, blue]
- # array. Default: 0
- # :word_fontname - This is either a string or array containing the name of the
- # font used in the word window. If an array, it will take the first font
- # in the array that the player has installed.
- # Default: ["Verdana", "Arial", "Courier New"]
- # :word_fontsize - This is the default size of the font in the word window.
- # Default: 20
- # :word_dim - If using dim, the sprite to stretch as a background for the word
- # box. Default: "MessageBack"
- # :word_use_dim - The setting for using dim. If 0, it will never use dim.
- # If 1, it will use the dim sprite. If 2, it will use dim only when the
- # message window is also using dim. Default: 2
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # ~ats_next only codes~
- # The following codes can only be set on a message by message basis with
- # ats_next or $game_message. ats_all and $game_ats does not work for these.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # :do_not_refresh - When this is set to true, the contents of the message
- # window will not refresh until it is turned off. This means that text
- # messages will be appended to all the previous messages even if there
- # are other events in between, such as a Show Picture or Control
- # Variables switch and so on... Note that you will not be able to change
- # the face either without forcibly setting a new page. To turn it off,
- # you need to use a ats_next (:do_not_refresh, false) right before the
- # last message that you want appended. I do not recommend doing anything
- # too fancy with this; the idea is to permit you to do small things, like
- # Showing a picture, turning a switch on or off or doing some stuff with
- # conditional branches in between drawing letters. It's not designed or
- # tested for much of anything else.
- # :character - This is the same idea as the \oc, \uc, etc... character
- # positioning codes. This allows you to place it prior to opening the
- # window however. Set this value to the ID of the character you want to
- # position it in reference to (0 => Player, >1 => Event with that ID.
- # :char_ref - This is how you want to place it. 0 => Over; 1 => Left;
- # 2 => Under; 3 => Right; 4 => Over if fits, otherwise under.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # You can set default values for all properties starting at line 766.
- #==============================================================================
- #==============================================================================
- # ** Game_ATS
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This class holds all of the default data for the ATS
- #==============================================================================
- class Game_ATS
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # EDITABLE REGION
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- MAX_LINES = 4 # See line 376.
- MESSAGE_SPEED = 0 # See line 378.
- SKIP_DISABLED = false # See line 380.
- APPEND_TEXT = true # See line 381.
- APPEND_CHOICE = true # See line 383.
- SCROLLING = true # See line 387.
- SCROLL_SPEED = 2 # See line 389.
- SCROLL_SHOW_ARROWS = true # See line 391.
- SCROLL_AUTOPAUSE = false # See line 394.
- SCROLL_REVIEW = true # See line 396.
- SCROLL_BY_PAGE = false # See line 399.
- PARAGRAPH_FORMAT = false # See line 400.
- JUSTIFIED_TEXT = false # See line 403.
- LETTER_SOUND = false # See line 406.
- LETTER_SE = "Open1", 40 # See line 408.
- LETTERS_PER_SE = 3 # See line 410.
- RANDOM_PITCH = 100..100 # See line 413.
- SPEECH_TAG_INDEX = -1 # See line 418.
- # SPEECH_TAG_GRAPHICS # See line 422.
- SPEECH_TAG_GRAPHICS = ["Speech Tag 1", "Speech Tag 2", "Thought Tag 1"]
- START_SOUND = false # See line 426.
- START_SE = "Chime2" # See line 428.
- FINISH_SOUND = false # See line 430.
- FINISH_SE = "Chime1" # See line 432.
- PAUSE_SOUND = false # See line 434.
- PAUSE_SE = "Decision2" # See line 436.
- TERMINATE_SOUND = false # See line 438.
- TERMINATE_SE = "Cancel" # See line 440.
- MOVE_WHEN_VISIBLE = false # See line 442.
- GRAPHIC_NOVEL = false # See line 447.
- HIDE_BUTTON = Input::F5 # See line 452.
- GN_PRESS_OR_TOGGLE = true # See line 454.
- FILTERS = { # See line 457.
- 'ATS' => '\c[1]Advanced Text System\c[0], Version 3.0',
- 0 => 'Numbered filters work too',
- }
- FILTERS.default = "" # <- Do not touch
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- MESSAGE_X = -1 # See line 464.
- MESSAGE_Y = -1 # See line 467.
- WLH = 24 # See line 471.
- BATTLE_WLH = 24 # See line 472.
- DO_NOT_OBSCURE = false # See line 474.
- OBSCURE_CHARACTERS = [0] # See line 477.
- OBSCURE_BUFFER = 32 # See line 485.
- FIT_WINDOW_TO_TEXT = false # See line 488.
- MESSAGE_WIDTH = 544 # See line 491.
- MESSAGE_HEIGHT = 128 # See line 493.
- MESSAGE_OPACITY = 255 # See line 495.
- MESSAGE_BACKOPACITY = 200 # See line 496.
- MESSAGE_WINDOWSKIN = "Window" # See line 498.
- MESSAGE_FONTCOLOUR = 0 # See line 500.
- MESSAGE_FONTNAME = ["Verdana", "Arial", "Courier New"] # See line 503.
- MESSAGE_FONTSIZE = 20 # See line 507.
- MESSAGE_FONTALPHA = 255 # See line 508.
- MESSAGE_DIM = "MessageBack" # See line 509.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- FACE_X = -1 # See line 512.
- FACE_Y = -1 # See line 515.
- FACE_Z = 10 # See line 518.
- FACE_SIDE = true # See line 520.
- FACE_OFFSET_X = 0 # See line 522.
- FACE_OFFSET_Y = 0 # See line 524.
- FACE_WIDTH = 0 # See line 526.
- FACE_HEIGHT = 0 # See line 529.
- FACE_MIRROR = false # See line 532.
- FACE_OPACITY = 255 # See line 533.
- FACE_BLEND_TYPE = 0 # See line 534.
- FACE_FADEIN = false # See line 536.
- FACE_FADE_SPEED = 10 # See line 538.
- FACE_SCROLL_X = false # See line 540.
- FACE_SCROLL_Y = false # See line 541.
- FACE_SCROLL_SPEED = 12 # See line 542.
- ANIMATE_FACES = true # See line 544.
- LETTERS_PER_FACE = 6 # See line 545.
- FACE_WINDOW = false # See line 551.
- FACE_WINDOW_OPACITY = 255 # See line 552.
- FACE_WINDOWSKIN = "Window" # See line 554.
- FACE_BORDER_SIZE = 6 # See line 556.
- FACE_DIM = "MessageBack" # See line 558.
- FACE_USE_DIM = 0 # See line 560.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- CHOICE_TEXT = " %s" # See line 564.
- DISABLED_CHOICE_TEXT = "\\FA[128]%s\\FA[255]" # See line 569.
- CHOICEBOX_TEXT = "%s" # See line 576.
- CHOICE_WINDOW = false # See line 578.
- CHOICE_X = -1 # See line 580.
- CHOICE_Y = -1 # See line 584.
- CHOICE_OFFSET_X = -16 # See line 587.
- CHOICE_OFFSET_Y = 16 # See line 589.
- CHOICE_WIDTH = 192 # See line 591.
- CHOICE_HEIGHT = -1 # See line 594.
- COLUMN_MAX = 1 # See line 596.
- ROW_MAX = 4 # See line 597.
- CHOICE_SPACING = 20 # See line 598.
- CHOICE_OPACITY = 255 # See line 600.
- CHOICE_BACKOPACITY = 200 # See line 601.
- CHOICE_WINDOWSKIN = "Window" # See line 603.
- CHOICE_FONTCOLOUR = 0 # See line 605.
- CHOICE_FONTNAME = ["Verdana", "Arial", "Courier New"] # See line 607.
- CHOICE_FONTSIZE = 20 # See line 610.
- CHOICE_WLH = -1 # See line 611.
- CHOICE_DIM = "MessageBack" # See line 612.
- CHOICE_USE_DIM = 2 # See line 614.
- CHOICE_ON_LINE = false # See line 617.
- CHOICE_OPPOSITE_FACE = true # See line 620.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- CHOICEHELP_X = -1 # See line 623.
- CHOICEHELP_Y = -1 # See line 625.
- CHOICEHELP_WIDTH = 544 # See line 628.
- CHOICEHELP_HEIGHT = -1 # See line 631.
- CHOICEHELP_CENTER = true # See line 634.
- CHOICEHELP_OPACITY = 255 # See line 636.
- CHOICEHELP_BACKOPACITY = 200 # See line 638.
- CHOICEHELP_WLH = -1 # See line 640.
- CHOICEHELP_WINDOWSKIN = "Window" # See line 642.
- CHOICEHELP_FONTCOLOUR = 0 # See line 645.
- CHOICEHELP_FONTNAME = ["Verdana", "Arial", "Courier New"] # See line 649.
- CHOICEHELP_FONTSIZE = 20 # See line 651.
- CHOICEHELP_DIM = "MessageBack"# See line 653.
- CHOICEHELP_USE_DIM = 2 # See line 655.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- NAME_X = -1 # See line 660.
- NAME_Y = -1 # See line 663.
- NAME_OFFSET_X = 16 # See line 666.
- NAME_OFFSET_Y = 16 # See line 668.
- NAME_OPACITY = 255 # See line 670.
- NAME_BACKOPACITY = 200 # See line 671.
- NAME_WINDOWSKIN = "Window" # See line 673.
- NAME_BORDER_SIZE = 8 # See line 675.
- NAME_WLH = -1 # See line 677.
- NAME_FONTCOLOUR = 0 # See line 679.
- NAME_FONTNAME = ["Verdana", "Arial", "Courier New"] # See line 682.
- NAME_FONTSIZE = 20 # See line 686.
- NAME_DIM = "MessageBack" # See line 688.
- NAME_USE_DIM = 2 # See line 690.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- WORD_X = -1 # See line 694.
- WORD_Y = -1 # See line 698.
- WORD_WIDTH = 160 # See line 704.
- WORD_HEIGHT = -1 # See line 706.
- WORD_OPACITY = 255 # See line 708.
- WORD_BACKOPACITY = 200 # See line 709.
- WORD_WINDOWSKIN = "Window" # See line 711.
- WORD_WLH = -1 # See line 713.
- WORD_FONTCOLOUR = 0 # See line 715.
- WORD_FONTNAME = ["Verdana", "Arial", "Courier New"] # See line 718.
- WORD_FONTSIZE = 20 # See line 722.
- WORD_DIM = "MessageBack" # See line 724.
- WORD_USE_DIM = 2 # See line 726.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # END EDITABLE REGION
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- ATS_2 = false
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variables
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # For each constant, create accessor
- for name in self.class.constants
- # Run the script
- attr_accessor name.downcase.to_sym
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize
- reset
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Reset
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def reset
- constants = Game_ATS.constants
- constants.each { |name|
- self.send ("#{name.downcase}=".to_sym, Game_ATS.const_get(name))
- }
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Sound Effect
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_sound_effect (settings)
- return settings if settings.is_a? (RPG::SE)
- settings = [settings] if settings.is_a? (String)
- settings[1] = 80 if !settings[1]
- return RPG::SE.new (*settings)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Overwrite SE methods * Thanks Zeriab
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- for method in ["letter", "terminate", "pause", "start", "finish"]
- # Run the script
- eval("def #{method}_se= (*args); @#{method}_se = set_sound_effect (*args); end")
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Random Pitch
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def random_pitch= (val)
- @random_pitch = val.is_a? (Integer) ? self.letter_se.pitch..val : val
- end
- end
- #==============================================================================
- # ** Game_Message
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # new attr_accessor - all Game_ATS accessors; char_ref; character;
- # appending_text; choices; disabled_choices; help_choices; skip_choices;
- # override_run
- # aliased methods - initialize; clear; busy
- # new methods - convert_special_characters; perform_substitution;
- # perform_conversion; play_se; random_pitch=
- #==============================================================================
- class Game_Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variables
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # For each ATS constant, create accessor
- for name in (Game_ATS.constants) do attr_accessor name.downcase.to_sym end
- # Non Game_ATS variables
- attr_accessor :char_ref
- attr_accessor :character
- attr_accessor :appending_text
- attr_accessor :choices
- attr_accessor :disabled_choices
- attr_accessor :skip_choices
- attr_accessor :help_choices
- attr_accessor :override_run
- attr_accessor :highlight
- attr_accessor :underline
- attr_accessor :do_not_refresh
- attr_accessor :do_not_start
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malgb_advtx_inliz_2fk9 initialize
- def initialize (*args)
- @do_not_refresh = false
- malgb_advtx_inliz_2fk9 (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Clear
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malg_ats3_clr_msg_9lo1 clear
- def clear (*args)
- @do_not_start = @do_not_refresh
- @texts = []
- @choices = []
- @disabled_choices = []
- @skip_choices = []
- @help_choices = []
- @choice_start = 99
- @choice_max = 0
- @choice_cancel_type = 0
- @choice_proc = nil
- @ignored_codes = []
- return if @do_not_start
- malg_ats3_clr_msg_9lo1 (*args) # Run Original Method
- @alignment = 0
- @appending_text = false
- @character = -1
- @char_ref = 0
- @override_run = false
- @highlight = -1
- @underline = false
- # Set ATS variables
- (Game_ATS.constants).each { |name|
- self.send ("#{name.downcase}=".to_sym, $game_ats.send (name.downcase.to_sym))
- }
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Busy?
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malbr_busy_ats3_8ik2 busy
- def busy (*args)
- return false if @appending_text
- return malbr_busy_ats3_8ik2 (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Convert Special Characters
- # text : the text to convert
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def convert_special_characters (text)
- return if text == nil
- @ignored_codes.clear
- # Remove Ignore code strings
- text.gsub! (/\\\$(.*?)\/\$/i) {
- @ignored_codes.push ($1.to_s)
- "\x0a<#{@ignored_codes.size - 1}>"
- }
- # Get substitutions
- text = perform_substitution (text)
- text = perform_conversion (text)
- text.gsub! (/\\\\/) { "\\" }
- text.gsub! (/\x0a<(\d+)>/) { @ignored_codes[$1.to_i] } # Recover Protected strings
- return text
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Convert Substitution Codes
- # text : the text to convert
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def perform_substitution (text)
- # Switch conditional text
- text.gsub! (/\\V\[(\d+)\]/i) { $game_variables[$1.to_i] } # Variable
- text.gsub! (/\\PID\[(\d+)\]/i) { $game_party.members[($1.to_i % $game_party.members.size)].id } # Party Member X
- text.gsub! (/\\P\[(\d+)\]/i) { $game_party.members[($1.to_i % $game_party.members.size)].id } # Party Member X
- text.gsub! (/\\V\[(\d+)\]/i) { $game_variables[$1.to_i] } # Variable
- # FILTERS
- text.gsub!(/\\F\[["'](.+?)["']\]/i) { Game_ATS::FILTERS[$1.to_s] }
- text.gsub!(/\\F\[(.+?)\]/i) { Game_ATS::FILTERS[$1.to_i] }
- # Party ID to Actor ID
- text.gsub!(/\\N\[([0-9]+)\]/i) { $game_actors[$1.to_i].name rescue ""} # Actor Name
- # New Codes
- text.gsub! (/\\AC\[(\d+)\]/i) { $game_actors[$1.to_i].class.name rescue "" } # Actor Class
- text.gsub! (/\\VOCAB\[(\w+)\]/i) { Vocab.send ($1.downcase) rescue "" }
- # Actor, Item, Weapon, Armor, Skill Stats
- data_arrays = [$game_actors, $data_items, $data_weapons, $data_armors,
- $data_skills, $data_states, $data_enemies]
- regexp_array = ["ACTOR_", "I_", "W_", "A_", "S_", "T_", "ENEMY_"]
- for i in 0...regexp_array.size
- regexp = regexp_array[i]
- data = data_arrays[i]
- if i != 0
- text.gsub! (/\\#{regexp}N\[(\d+)\]/i) {
- id = $1.to_i
- data[id].note[/\\MSG\[(.+?)\]MSG\//i].nil? ? data[id].note : $1.to_s.gsub (/\n/) { "" } # Remove \n
- }
- end
- # Item Stats
- text.gsub! (/\\#{regexp}([^\[]+?)\[(\d+)\]/i) { |match| data[$2.to_i].send ($1.downcase).to_s rescue match }
- end
- text.gsub! (/\\MAP\[(\d+)\]/i) { (load_data ("Data/MapInfos.rvdata"))[$1.to_i].name rescue "" }
- text.gsub! (/\\MAP/i) { (load_data ("Data/MapInfos.rvdata"))[$game_map.map_id].name rescue "" }
- text.gsub! (/\\NL\[(\d+)\]/i){ $data_system.elements[$1.to_i] rescue "" }
- text.gsub! (/\\NC\[(\d+)\]/i) { $data_classes[$1.to_i].name rescue "" } # Class Name
- text.gsub! (/\\NE\[(\d+)\]/i) { $game_map.events[$1.to_i].name rescue "" } # Event Name
- text.gsub! (/\\NM\[(\d+)\]/i) { $data_enemies[$1.to_i].name rescue "" } # Monster Name
- text.gsub! (/\\NI\[(\d+)\]/i) { $data_items[$1.to_i].name rescue "" } # Item Name
- text.gsub! (/\\NW\[(\d+)\]/i) { $data_weapons[$1.to_i].name rescue "" } # Weapon Name
- text.gsub! (/\\NA\[(\d+)\]/i) { $data_armors[$1.to_i].name rescue "" } # Armor Name
- text.gsub! (/\\NS\[(\d+)\]/i) { $data_skills[$1.to_i].name rescue "" } # Skill Name
- text.gsub! (/\\NT\[(\d+)\]/i) { $data_states[$1.to_i].name rescue "" } # State Name
- text.gsub! (/\\NP\[(\d+)\]/i) { $game_party.members[($1.to_i % $game_party.members.size)].name } # Party Name
- text.gsub! (/\\NV\[(\d+)\]/i) { $data_system.variables[$1.to_i] rescue "" } # Variable Name
- text.gsub! (/\\NSW\[(\d+)\]/i){ $data_system.switches[$1.to_i] rescue "" } # Switch Name
- text.gsub! (/\\PI\[(\d+)\]/i) { $data_items[$1.to_i].price.to_s rescue "" } # Item Price
- text.gsub! (/\\PW\[(\d+)\]/i) { $data_weapons[$1.to_i].price.to_s rescue "" } # Weapon Price
- text.gsub! (/\\PA\[(\d+)\]/i) { $data_armors[$1.to_i].price.to_s rescue "" } # Armor Price
- text.gsub! (/\\DI\[(\d+)\]/i) { $data_items[$1.to_i].description rescue "" } # Item Description
- text.gsub! (/\\DW\[(\d+)\]/i) { $data_weapons[$1.to_i].description rescue "" } # Weapon Description
- text.gsub! (/\\DA\[(\d+)\]/i) { $data_armors[$1.to_i].description rescue "" } # Armor Description
- text.gsub! (/\\DS\[(\d+)\]/i) { $data_skills[$1.to_i].description rescue "" } # Skill Description
- text.gsub! (/\\I#\[(\d+)\]/i) { $game_party.item_number ($data_items[$1.to_i]) } # Item Number
- text.gsub! (/\\W#\[(\d+)\]/i) { $game_party.item_number ($data_weapons[$1.to_i]) } # Weapon Number
- text.gsub! (/\\A#\[(\d+)\]/i) { $game_party.item_number ($data_armors[$1.to_i]) } # Armor Number
- text.gsub! (/\\S\!<(\d+),(.+?)>/i) { $game_switches[$1.to_i] ? "" : $2.to_s }
- text.gsub! (/\\S<(\d+),(.+?)>/i) { $game_switches[$1.to_i] ? $2.to_s : "" }
- text.gsub! (/\\#\{(.+?)\}#/im) { (eval ($1.to_s)).to_s rescue "" }
- return text.sub! (/\\RESUB/i, "") != nil ? perform_substitution (text) : text
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Perform Conversion
- # text : the text to convert
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def perform_conversion (text)
- text.gsub! (/\\C\[(\d+)\]/i) { "\x01<#{$1}>" } # Colour
- text.gsub! (/\\C\[#([\dABCDEF]{6,6})\]/i) { "\x01<##{$1}>"} # Colour Hex
- text.gsub! (/\\G/i) { "\x02" } # Gold Window
- text.gsub! (/\\\./) { "\x03<15>" } # Wait 15 frames
- text.gsub! (/\\\|/) { "\x03<60>" } # Wait 60 frames
- text.gsub! (/\\W\[(\d+)\]/i) { "\x03<#{$1}>" } # Wait x frames
- text.gsub! (/\\!/) { "\x04" } # Wait for Input
- text.gsub! (/\\@@/) { "\x05<0>" } # Show Fast ON
- text.gsub! (/\/@@/) { "\x05<1>" } # Show Fast OFF
- text.gsub! (/\\@/) { "\x06<0>" } # Show Line Fast ON
- text.gsub! (/\/@/) { "\x06<1>" } # Show Line Fast OFF
- text.gsub! (/\\\^/) { "\x07" } # Skip Pause
- text.gsub! (/\\>/) { "\x08<-1>" } # Message speed- 1
- text.gsub! (/\\</) { "\x08<1>" } # Message speed + 1
- text.gsub! (/\\[Ss]\[(=?-?\d+)\]/i) { "\x08<#{$1}>" } # Message speed + x
- text.gsub! (/\\%/) { "\xb0<0>" } # Enable Skip
- text.gsub! (/\/%/) { "\xb0<1>" } # Disable Skip
- # Animation and Balloons
- text.gsub! (/\\ANI\[(\d+),\s*(\d+)\]/i) { "\x0b<#{$1},#{$2},0>" } # Animation
- text.gsub! (/\\BLN\[(\d+),\s*(\d+)\]/i) { "\x0b<#{$1},#{$2},1>" } # Balloon
- # Position to Character
- text.gsub! (/\\OC\[(\d+)\]/i) { "\x0c<#{$1},0>" } # Over Character
- text.gsub! (/\\LC\[(\d+)\]/i) { "\x0c<#{$1},1>" } # Left of Character
- text.gsub! (/\\UC\[(\d+)\]/i) { "\x0c<#{$1},2>" } # Under Character
- text.gsub! (/\\RC\[(\d+)\]/i) { "\x0c<#{$1},3>" } # Right of Character
- text.gsub! (/\\E\[(\d+)\]/i) { "\x0c<#{$1},4>" } # Under if over doesn't work
- text.gsub! (/\\SE\[(.+?)\]/i) { "\x1b<#{$1},SE>" } # Play Sound Effect
- text.gsub! (/\\ME\[(.+?)\]/i) { "\x1b<#{$1},ME>" } # Play Musical Effect
- # Show Icons
- text.gsub! (/\\IC?O?N?\[(\d+)\]/i) { "\x0d<#{$1}>" } # Show Icon X
- text.gsub! (/\\IIC?O?N?\[(\d+)\]/i) { "\x0d<#{$data_items[$1.to_i].icon_index}>" rescue "" } # Item Icon
- text.gsub! (/\\WIC?O?N?\[(\d+)\]/i) { "\x0d<#{$data_weapons[$1.to_i].icon_index}>" rescue "" } # Weapon Icon
- text.gsub! (/\\AIC?O?N?\[(\d+)\]/i) { "\x0d<#{$data_armors[$1.to_i].icon_index}>" rescue "" } # Armor Icon
- text.gsub! (/\\SIC?O?N?\[(\d+)\]/i) { "\x0d<#{$data_skills[$1.to_i].icon_index}>" rescue "" }
- text.gsub! (/\\TIC?O?N?\[(\d+)\]/i) { "\x0d<#{$data_states[$1.to_i].icon_index}>" rescue "" }
- text.gsub! (/\\[Bb]/) { "\x0e<0>" } # Bold ON
- text.gsub! (/\/[Bb]/) { "\x0e<1>" } # Bold OFF
- text.gsub! (/\\[Ii]/) { "\x0f<0>" } # Italics ON
- text.gsub! (/\/[Ii]/) { "\x0f<1>" } # Italics OFF
- text.gsub! (/\\[Ss]/) { "\x10<0>" } # Shadow ON
- text.gsub! (/\/[Ss]/) { "\x10<1>" } # Shadow OFF
- text.gsub! (/\\[Uu]/) { "\x11<0>" } # Underline ON
- text.gsub! (/\/[Uu]/) { "\x11<1>" } # Underline OFF
- text.gsub! (/\\HL\[(-?\d+)\]/i) { "\x12<#{$1}>" } # Higlight X
- text.gsub! (/\/HL/i) { "\x12<-1>" } # Highlight OFF
- text.gsub! (/\\FN\[(.+?)\]/i) { "\x13<#{$1}>" } # Font Name
- text.gsub! (/\\FS\[(\d+)\]/i) { "\x14<#{$1}>" } # Font Size
- text.gsub! (/\\FA\[(\d+)\]/i) { "\x15<#{$1}>" } # Font Alpha
- text.gsub! (/\\LB/i) { "\x16" } # Force Line Break
- text.gsub! (/\\AF\[(\d+)\]/i) { "\x17<#{$1.to_s}>" } # Use Actor Face
- text.gsub! (/\\LEFT/i) { "\x18<0>" } # Align Left
- text.gsub! (/\\L/i) { "\x18<0>" } # Align Left
- text.gsub! (/\\CENTRE/i) { "\x18<1>" } # Align Centre
- text.gsub! (/\\CE?NTE?R/i) { "\x18<1>" } # Align Centre
- text.gsub! (/\\C/i) { "\x18<1>" } # Align Centre
- text.gsub! (/\\RI?GHT/i) { "\x18<2>" } # Align Right
- text.gsub! (/\\R/i) { "\x18<2>" } # Align Right
- text.gsub! (/\\PB/i) { "\x1d" } # Force Page Break
- text.gsub! (/(\x1d\s*)\x00/i) { $1.to_s } # If force page, remove x00 code
- text.gsub! (/\\T/i) { "\x09" } # Tab
- text.gsub! (/\\X\[(\d+)\]/i) { "\xb1<#{$1}>" } # Content X
- # Position Direct Setting
- text.gsub! (/\\[PM]XY\[(-?\d+),\s*(-?\d+)\]/im) { "\x1f<0,#{$1.to_s},#{$2.to_s}>" }
- # Face Direct Setting
- text.gsub! (/\\FXY\[(-?\d+),\s*(-?\d+)\]/im) { "\x1f<1,#{$1.to_s},#{$2.to_s}>" }
- # Name Direct Setting
- text.gsub! (/\\NXY\[(-?\d+),\s*(-?\d+)\]/im) { "\x1f<2,#{$1.to_s},#{$2.to_s}>" }
- text.gsub! (/\\#\!\{(.+?)\}#/im) { "\x7f{#{$1}#}" }
- text.gsub! (/\\NB\[(.*?)\]/im) { "\x19{#{$1}}" } # Name Window
- text.gsub! (/\/NB/i) { "\x19{}"}
- text.gsub! (/\\NAME\[(.*?)\]/im) { "\x19{#{$1}}" } # Name Window
- text.gsub! (/\\WB\[(.*?)\]/im) { "\x1a{#{$1}}" } # Word Box
- text.gsub! (/\/WB/i) { "\x1a{}" }
- return text
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Play SE
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def play_se (se)
- # Avoid FileErrors
- begin
- se.play
- rescue
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Choice Texts
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def choice_text= (string)
- if string.is_a? (String)
- @choice_text = convert_special_characters (string)
- @choice_text += "%s" if @choice_text[/%s/] == nil
- else
- @choice_text = "%s"
- end
- end
- def choicebox_text= (string)
- if string.is_a? (String)
- @choicebox_text = convert_special_characters (string)
- @choicebox_text += "%s" if @choicebox_text[/%s/] == nil
- else
- @choicebox_text = "%s"
- end
- end
- def disabled_choice_text= (string)
- @disabled_choice_text = string.is_a? (String) ? convert_special_characters (string) : "%s"
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Random Pitch
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def random_pitch= (val)
- @random_pitch = val.is_a? (Integer) ? self.letter_se.pitch..val : val
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Overwrite SE methods * Thanks Zeriab
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- for method in ["letter", "terminate", "pause", "start", "finish"]
- # Run the script
- eval("def #{method}_se= (*args); @#{method}_se = $game_ats.set_sound_effect (*args); end")
- end
- end
- #==============================================================================
- # ** Game_Event
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # new method - name
- #==============================================================================
- class Game_Event
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Name
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def name
- return @event.name
- end
- end
- #==============================================================================
- # ** Game_Player
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # aliased methods - movable?; move_by_input
- #==============================================================================
- class Game_Player
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Move By Input
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias mabr_adtxs3_inpmv_6yw2 move_by_input
- def move_by_input (*args)
- $game_message.override_run = $game_message.move_when_visible
- mabr_adtxs3_inpmv_6yw2 (*args) # Run Original Method
- $game_message.override_run = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Check if Player can Move
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malg_advtxt3_movble_5sa2 movable?
- def movable? (*args)
- true_visible = $game_message.visible
- $game_message.visible = false if $game_message.move_when_visible
- check = malg_advtxt3_movble_5sa2 (*args) # Run Original Method
- $game_message.visible = true_visible
- return check
- end
- end
- #==============================================================================
- # ** Game_Interpreter
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # overwritten methods - command_403; setup_choices; setup_num_input
- # aliased methods - command_101; command_102; running?
- # new methods - interpret_choices; choice_plus; choice_switch; choice_help;
- # ats_next; ats_all
- #==============================================================================
- class Game_Interpreter
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Show Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats_apnd_txt_show_94b command_101
- def command_101 (*args)
- value = modalg_ats_apnd_txt_show_94b (*args)
- if $game_message.append_text && @list[@index].code == 101 && @list[@index].parameters == @params
- $game_message.appending_text = true
- value = command_101 (*args)
- $game_message.appending_text = false
- end
- return value
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Show Choices
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malgr_ats3_shwchc_4ac2 command_102
- def command_102 (*args)
- if @list[@index].indent > 1000
- @list[@index - 1].indent -= 1000
- @list[@index].indent -= 1000
- return command_skip
- else
- return malgr_ats3_shwchc_4ac2 (*args) # Run Original Method
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * When [Cancel]
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def command_403
- if @branch[@indent] == 999 # If canceling choice
- @branch.delete(@indent) # Erase branching data
- return true # Continue
- else # If doesn't match condition
- return command_skip # Command skip
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Setup Choices
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def setup_choices (params)
- params = interpret_choices (Marshal.load (Marshal.dump (params)))
- $game_message.choice_start = $game_message.texts.size
- $game_message.choice_max = params[0].size
- for s in params[0]
- $game_message.choices.push(s)
- end
- $game_message.texts.push ("\x1c") if $game_message.texts.empty?
- $game_message.choice_cancel_type = params[1]
- $game_message.choice_proc = Proc.new { |n| @branch[@indent] = n }
- @index += 1
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Number Input Setup
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def setup_num_input(params)
- if $game_message.texts.size < $game_message.max_lines || $game_message.scrolling
- $game_message.num_input_variable_id = params[0]
- $game_message.num_input_digits_max = params[1]
- @index += 1
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Interpret Choices
- # params : the parameters of the initial 102 command.
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def interpret_choices (params)
- # Collect all next choices as well.
- ind = @index + 1
- choice_id = 0
- params[1] = 1000 if params[1] == 5
- choice_text = $game_message.choice_window ? $game_message.choicebox_text : $game_message.choice_text
- loop do
- # Advance to next choice code
- while (@list[ind].indent % 1000) > @indent
- ind += 1 # Advance index
- end
- case @list[ind].code
- when 402
- choice_s = @list[ind].parameters[1].dup
- ind += 1
- # Choice+ processing.
- choice_s, ind = choice_plus (choice_s, ind)
- # SOFF and SON processing
- choice_s, delete, disable = choice_switch (choice_s)
- choice_s, help = choice_help (choice_s)
- if delete || choice_s.empty?
- @list[ind - 1].parameters[0] = -1
- params[0].delete_at (choice_id)
- else
- $game_message.help_choices[choice_id] = help
- choice_s = sprintf (choice_text, choice_s)
- if disable
- choice_s = sprintf ($game_message.disabled_choice_text, choice_s)
- $game_message.disabled_choices.push (choice_id)
- end
- # Choice Skip?
- choice_s.gsub! (/\x1e/i) { $game_message.skip_choices.push (choice_id); "" }
- @list[ind - 1].parameters[0] = choice_id
- params[0][choice_id] = choice_s
- choice_id += 1
- end
- when 403
- ind += 1
- when 404
- if !$game_message.append_choice || @list[ind + 1].code != 102
- @index = ind if $game_message.skip_choices.size == params.size
- $game_message.help_choices.clear if $game_message.help_choices.uniq.size == 1 && $game_message.help_choices[0].empty?
- break
- end
- p2 = @list[ind + 1].parameters.dup
- @list[ind].indent += 1000 if @list[ind].indent < 1000
- @list[ind + 1].indent += 1000 if @list[ind + 1].indent < 1000
- params[1] = p2[1] == 5 ? 1000 : p2[1] == 0 ? params[1] : params[0].size + p2[1]
- params[0].push (*p2[0])
- ind += 2
- else
- break
- end
- end
- return params
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Running?
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modral_atsys3_runn_5tg3 running?
- def running? (*args)
- return false if $game_message.override_run
- return modral_atsys3_runn_5tg3 (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Choice + Processing
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def choice_plus (choice_s, ind)
- # Choice + Processing
- if @list[ind].code == 108 # Comment
- string = @list[ind].parameters[0].dup
- ind2 = ind + 1
- while @list[ind2].code == 408
- string += @list[ind2].parameters[0]
- ind2 += 1
- end
- string.gsub (/\\\+{(.+?)}/im) { choice_s += $1.to_s; "" }
- choice_s.gsub! (/\n/) { "" } # Remove \n
- end
- return choice_s, ind
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Choice Switch
- # s : the choice string
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def choice_switch (s)
- del = false
- dis = false
- s.gsub! (/\\SOFF\[(\d+)\]/i) { del = true if $game_switches[$1.to_i]; "" }
- s.gsub! (/\\SON\[(\d+)\]/i) { del = true if !$game_switches[$1.to_i]; "" }
- if !del
- s.gsub! (/\\D\[(\d+)\]/i) { dis = true if !$game_switches[$1.to_i]; "" }
- s.gsub! (/\\D!\[(\d+)\]/i) { dis = true if $game_switches[$1.to_i]; "" }
- s.gsub! (/\\SKIP/i) { "\x1e" }
- s.gsub! (/\\PB/i) { "" } # Delete any page breaks.
- $game_message.convert_special_characters (s)
- s.gsub! (/\x16/) { "\x00" } # Force Line Break
- end
- return s, del, dis
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Choice Help
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def choice_help (choice_s)
- help_text = ""
- choice_s.gsub! (/\x1a{(.+?)}/im) { help_text += $1.to_s; "" }
- return choice_s, help_text
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Change ATS parameter for next message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def ats_next (parameter, *args)
- $game_message.send ("#{parameter}=".to_sym, *args) unless args.empty?
- return $game_message.send (parameter)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Change ATS
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def ats_all (parameter, *args)
- $game_ats.send ("#{parameter}=".to_sym, *args) unless args.empty?
- $game_message.send ("#{parameter}=".to_sym, *args) unless args.empty?
- return $game_message.send (parameter)
- end
- end
- #==============================================================================
- # ** P_Formatter_ATS
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # A special formatter class designed to accomodate ATS message codes
- #==============================================================================
- class P_Formatter_ATS
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variables
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- attr_accessor :bitmap
- attr_reader :force_break
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (font = nil)
- @bitmap = Bitmap.new (1, 1)
- @bitmap.font = font if font
- @curly_args_codes = ["\x19", "\x1a", "\x7f"]
- @args_codes = ["\x01", "\x03", "\x05", "\x06", "\x08", "\x0b",
- "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13", "\x14",
- "\x15", "\x17", "\x18", "\x1b", "\x1f", "\xb0", "\xb1"]
- @no_args_codes = ["\x00", "\x02", "\x04", "\x07", "\x09", "\x16", "\x1c",
- "\x1d", "\x1e"]
- @force_break = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose Bitmap
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose
- @bitmap.dispose unless @bitmap.nil? || @bitmap.disposed?
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Format By Line
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def format_by_line (string, width)
- @string = string
- @max_width = width
- @justify = $game_message.justified_text
- return 0, 0, @justify if string.empty?
- @line_width = 0
- @word_length = 0
- @w_draw_count = 0
- @l_draw_count = 0
- @curly_argument = 0
- @code_argument = 0
- # Set up
- @line_space = 0
- @last_word = 0
- @break_loop = false
- @last_space_counted = false
- @force_break = false
- i = 0
- while !@break_loop
- if i >= @string.size
- if @l_draw_count != 0
- @l_draw_count += 1
- @line_width += @bitmap.text_size (" ").width
- end
- @l_draw_count += @w_draw_count
- @line_width += @word_length
- next_line (i)
- else
- format_character (i)
- i += 1
- end
- end
- return @line_space, @l_draw_count, @justify
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Format Character
- # i : index of character to format, or the character
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def format_character (i)
- character = @string[i, 1]
- if @curly_argument > 0
- @curly_argument -= 1 if character == "}"
- elsif @code_argument > 0
- @code_argument -= 1 if character == ">"
- elsif @curly_args_codes.include? (character)
- extract_curly_args_code (character, i)
- elsif @args_codes.include? (character)
- extract_args_code (character, i)
- elsif @no_args_codes.include? (character)
- extract_no_args_code (character, i)
- elsif character == " "
- next_word (i)
- return if @break_loop
- @line_width += @bitmap.text_size (" ").width
- @l_draw_count += 1
- @last_space_counted = true
- else # Regular Character
- @word_length += @bitmap.text_size(character).width
- @w_draw_count += 1
- if i == @string.size - 1 && @line_width + @word_length > @max_width
- next_line (@last_word)
- end
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Next Word
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def next_word (i)
- if @line_width + @word_length > @max_width
- if @line_width == 0
- @last_word = i
- @line_width = @word_length
- @l_draw_count = @w_draw_count
- @word_length = 0
- @w_draw_count = 0
- end
- next_line (@last_word)
- end
- @last_word = i
- @line_width += @word_length
- @l_draw_count += @w_draw_count
- @word_length = 0
- @w_draw_count = 0
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Proceed to Next Line
- # last_word : the index of the beginning of the previous word
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def next_line (last_word)
- @justify = false if last_word == @string.size
- @string[last_word, 1] = "\x00"
- if @last_space_counted
- @line_width -= @bitmap.text_size (" ").width
- @l_draw_count -= 1
- end
- # Calculates the blank space left to cover in the line
- line_blank = @max_width - @line_width
- @line_space = ( line_blank.to_f / [(@l_draw_count.to_f - 1.0), 1.0].max )
- @break_loop = true
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Extract Curly Argument Code
- # code : the code to extract
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def extract_curly_args_code (code, index)
- @curly_argument += 1
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Extract Argument Code
- # code : the code to extract
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def extract_args_code (code, index)
- case code
- when "\x0d" # Icon
- @w_draw_count += 1
- @word_length += 24
- when "\x0e" # Bold
- @bitmap.font.bold = (@string[index + 2, 1].to_i == 0)
- when "\x0f" # Italic
- @bitmap.font.italic = (@string[index + 2, 1].to_i == 0)
- when "\x10" # Shadow
- @bitmap.font.shadow = (@string[index + 2, 1].to_i == 0)
- when "\x13" # Font Name
- bmp = @bitmap
- bmp.font.name = bmp.font.name.to_ary if !bmp.font.name.is_a? (Array)
- @string[index, @string.size - index][/<(.*?)>/]
- bmp.font.name = ([$1.to_s] + bmp.font.name).uniq
- when "\x14" # Font Size
- @string[index, @string.size - index][/<(\d*)>/]
- @bitmap.font.size = $1.to_i
- when "\xb1" # Set Contents_X
- @string[index, @string.size - index][/<(\d*)>/]
- @word_length = $1.to_i
- end
- @code_argument += 1
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Extract No Argument Code
- # code : the code to extract
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def extract_no_args_code (code, index)
- if ["\x00", "\x1d"].include? (code) # New line or New Page
- if @line_width + @word_length > @max_width
- next_line (@last_word)
- else
- @line_width += @word_length
- @l_draw_count += @w_draw_count
- line_blank = @max_width - @line_width
- @line_space = ( line_blank.to_f / [(@l_draw_count.to_f - 1.0), 1.0].max )
- @break_loop = true
- @justify = false
- @force_break = true
- end
- elsif code == "\x09" # Tab
- next_word (index)
- @line_width = $game_message.justified_text ? @line_width + 32 :((@line_width / 32) + 1)*32
- end
- end
- end
- #==============================================================================
- # ** Sprite MessageFace
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This sprite displays face graphics
- #==============================================================================
- class Sprite_MessageFace < Sprite_Base
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (face_file, face_index, viewport = nil)
- super (viewport)
- wdth, hght = $game_message.face_width, $game_message.face_height
- face = Cache.face (face_file)
- if face_file[/^\$/] != nil # SINGLE
- wdth = face.width if wdth <= 0
- wdth = [face.width, wdth].min
- hght = face.height if hght <= 0
- hght = [face.height, hght].min
- rect = Rect.new((face.width-wdth) / 2, (face.height-hght) / 2, wdth, hght)
- else
- # Resize if face smaller than allotted size
- wdth = face.width / 4 if wdth <= 0
- wdth = [face.width / 4, wdth].min
- hght = face.height / 2 if hght <= 0
- hght = [face.height / 2, hght].min
- rect = Rect.new(0, 0, wdth, hght)
- rect.x = (face_index % 4) * wdth + ((face.width / 4) - wdth) / 2
- rect.y = (face_index / 4) * hght + ((face.height / 2) - hght) / 2
- end
- self.bitmap = Bitmap.new (rect.width, rect.height)
- self.bitmap.blt(0, 0, face, rect)
- self.mirror = $game_message.face_mirror
- self.blend_type = $game_message.face_blend_type
- self.visible = false
- self.opacity = $game_message.face_fadein ? 0 : $game_message.face_opacity
- $game_message.face_width, $game_message.face_height = rect.width, rect.height
- end
- end
- #==============================================================================
- # ** Sprite SpeechTag
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This sprite displays the tag when speaking
- #==============================================================================
- class Sprite_SpeechTag < Sprite
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variable
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- attr_reader :speech_tag_index
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (viewport = nil, *args)
- @border_sprite = Sprite.new (viewport)
- super (viewport, *args)
- @border_sprite.z = self.z + 1
- @bitmaps = []
- reset_graphic
- self.visible = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose (*args)
- if self.bitmap
- self.bitmap.dispose
- @border_sprite.bitmap.dispose
- end
- @border_sprite.dispose
- super (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Reset Graphic
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def reset_graphic (index = $game_message.speech_tag_index)
- return if @speech_tag_index == index
- @speech_tag_index = index
- return if index < 0
- begin
- bitmap = Cache.system ($game_message.speech_tag_graphics[index])
- rescue
- return
- end
- @bitmaps.each { |bmp| bmp.dispose unless bmp.disposed? }
- @bitmaps.clear
- dummy_bmp = Bitmap.new (bitmap.width / 2, bitmap.height / 2)
- src_rect = Rect.new (0, 0, bitmap.width / 2, bitmap.height / 2)
- for i in 0...4
- new_bmp = dummy_bmp.dup
- src_rect.x, src_rect.y = (i % 2)*new_bmp.width, (i / 2)*new_bmp.height
- new_bmp.blt (0, 0, bitmap, src_rect)
- @bitmaps.push (new_bmp)
- end
- dummy_bmp.dispose
- self.bitmap = @bitmaps[0]
- @border_sprite.bitmap = @bitmaps[1]
- self.back_opacity = $game_message.message_backopacity
- self.opacity = $game_message.message_opacity
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Direction
- # dir : 0 => Down; 2 => Up
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_direction (dir)
- self.bitmap = @bitmaps[dir]
- @border_sprite.bitmap = @bitmaps[dir + 1]
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Back Opacity
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias back_opacity= opacity= unless self.method_defined? (:back_opacity=)
- def opacity= (value)
- self.back_opacity = (self.opacity*(value.to_f / 255.0)).to_i
- @border_sprite.opacity = value
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Visible
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def visible= (boolean)
- super (boolean)
- @border_sprite.visible = boolean
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * X=, Y=, Z=, Angle
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- for attr in ["x", "y", "z", "angle"]
- ATS_ATTR = <<_END_
- def #{attr}= (*args)
- old_val = self.#{attr}
- super (*args)
- diff = self.#{attr} - old_val
- @border_sprite.#{attr} += diff
- end
- _END_
- eval (ATS_ATTR)
- end
- end
- #==============================================================================
- # *** Window_MessageBase
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This module holds methods shared by all ATS windows
- #==============================================================================
- module Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Message Draw Icon
- # allows for different opacities
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def message_draw_icon (icon_index, x, y, o = $game_message.message_fontalpha)
- bitmap = Cache.system("Iconset")
- rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
- self.contents.blt(x, y, bitmap, rect, o)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Text Color
- # n : either a windowskin palette or the array
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def text_color (n)
- if n.is_a? (Array)
- return Color.new (*n)
- else
- return super (n)
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Alignment
- # align : The alignment ( 1 => Centre, 2 => Right )
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_alignment (align = 1)
- # Get rest of line
- formatter = P_Formatter_ATS.new (self.contents.font.dup)
- ls, lc, j = formatter.format_by_line (@text.dup, @contents_width - @contents_x)
- formatter.dispose
- es = ls * (lc - 1)
- @contents_x += (es / 2)*align
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Message Character
- # c : the character to be drawn
- #``````````````````````````````````````````````````````````````````````````
- # This method utilizes the codes shared between the MessageBox, WordBox,
- # and ChoiceBox
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_message_character (c, bmp = self.contents)
- @text = "" if @text.nil?
- case c
- when "\x01" # \C[n] (text character color change)
- @text.sub! (/<(#?)(.+?)>/i, "")
- if $1 == ""
- bmp.font.color = text_color($2.to_i)
- if $game_message.message_fontalpha != 255
- bmp.font.color.alpha = $game_message.message_fontalpha
- end
- else
- a = $2.to_s.scan (/../)
- bmp.font.color = text_color ([a[0].to_i (16), a[1].to_i (16), a[2].to_i (16), $game_message.message_fontalpha])
- end
- when "\x09" # Tab
- x = @line_x + (((@contents_x - @line_x).to_i / 32) + 1)*32
- highlight_underline (x - @contents_x)
- @contents_x = x
- when "\xb1" # Set Contents X
- @text.sub! (/<(\d*)>/, "")
- @contents_x = $1.to_i
- return false if self.is_a? (Window_Message)
- when "\x0d" # Icon
- @text.sub!(/<(\d*)>/, "")
- highlight_underline (24)
- message_draw_icon ($1.to_i, @contents_x, @contents_y)
- @contents_x += 24
- @contents_x += @ls if self.is_a? (Window_Message)
- when "\x0e" # Bold
- @text.sub!(/<([01])>/, "")
- bmp.font.bold = (Game_ATS::ATS_2 && $1.to_i == 0) ? !bmp.font.bold : $1.to_i == 0
- when "\x0f" # Italics
- @text.sub!(/<([01])>/, "")
- bmp.font.italic = (Game_ATS::ATS_2 && $1.to_i == 0) ? !bmp.font.italic : $1.to_i == 0
- when "\x10" # Shadow
- @text.sub!(/<([01])>/, "")
- bmp.font.shadow = (Game_ATS::ATS_2 && $1.to_i == 0) ? !bmp.font.shadow : $1.to_i == 0
- when "\x11" # Underline
- @text.sub!(/<([01])>/, "")
- @underline = (Game_ATS::ATS_2 && $1.to_i == 0) ? !@underline : $1.to_i == 0
- when "\x12" # Highlight
- @text.sub! (/<(-?\d+)>/, "")
- @highlight = $1.to_i
- when "\x13" # Font Name
- bmp.font.name = bmp.font.name.to_ary if !bmp.font.name.is_a? (Array)
- @text.sub!(/<(.*?)>/, "")
- bmp.font.name = ([$1.to_s] + bmp.font.name).uniq
- when "\x14" # Font Size
- @text.sub!(/<(\d*)>/, "")
- bmp.font.size = $1.to_i
- when "\x15" # Font Alpha
- @text.sub! (/<(\d*)>/, "")
- $game_message.message_fontalpha = $1.to_i
- bmp.font.color.alpha = $game_message.message_fontalpha
- when "\x18" # Alignment
- @text.sub! (/<([012])>/, "")
- return true if @align == $1.to_i
- @align = $1.to_i
- set_alignment (@align)
- else
- return false
- end
- return true
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Regular Character
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_regular_character (c, bmp = self.contents)
- c_width = bmp.text_size(c).width
- c_width += @ls if !@ls.nil?
- highlight_underline (c_width)
- bmp.draw_text(@contents_x, @contents_y, c_width + 4, @wlh, c)
- @contents_x += c_width
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Highlight and Underline section
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def highlight_underline (c_width)
- # Highlight
- if @highlight >=0
- hl_rect = Rect.new (@contents_x, @contents_y + 1, c_width, @wlh - 2)
- colour = text_color (@highlight)
- colour.alpha = 128 if colour.alpha > 128
- contents.fill_rect (hl_rect, colour)
- end
- # Underline
- if @underline
- y = @contents_y + contents.font.size + (@wlh - contents.font.size) / 2
- contents.fill_rect (@contents_x, y, c_width, 2, contents.font.color)
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Background Sprite
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_back_sprite (dim, use_dim)
- @back_sprite.viewport = self.viewport
- bmp = Cache.system(dim)
- @back_sprite.bitmap = Bitmap.new (self.width, self.height)
- @back_sprite.bitmap.stretch_blt (@back_sprite.bitmap.rect, bmp, bmp.rect)
- if use_dim.is_a? (Integer)
- @back_sprite.visible = use_dim == 0 ? false : use_dim == 1 ? true : $game_message.background == 1
- else
- @back_sprite.visible = use_dim
- end
- @back_sprite.x = self.x
- @back_sprite.y = self.y
- @back_sprite.z = self.z - 10
- self.opacity = 0 if @back_sprite.visible
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * X, Y, Z
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- for attr in ["x", "y", "z"]
- ATS_NAMATTR = <<__END__
- def #{attr}= (*args)
- old_val = self.#{attr}
- super (*args)
- diff = self.#{attr} - old_val
- @back_sprite.#{attr} += diff
- end
- __END__
- eval (ATS_NAMATTR)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Get Top Row
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def top_row
- return super if !@wlh
- return self.oy / @wlh
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Top Row
- # row : row shown on top
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def top_row=(row)
- if !@wlh
- super (row)
- else
- row = 0 if row < 0
- self.oy = row * @wlh
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Get Number of Rows Displayable on 1 Page
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def page_row_max
- return super if !@wlh
- return (self.height - 32) / @wlh
- end
- end
- #==============================================================================
- # ** Window_WordBox
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This window will show a single line of text
- #==============================================================================
- class Window_WordBox < Window_Base
- include Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (viewport, word, x = 0, y = 0, width = -1, height = 56, name = false)
- @back_sprite = Sprite.new (viewport)
- @text = $game_message.convert_special_characters (word)
- @wlh = name ? $game_message.name_wlh : $game_message.word_wlh
- @wlh = $game_message.wlh if @wlh < 0
- height = 32 + (((word.scan (/\x00/).size) + 1)*@wlh) if height == -1
- @underline = false
- @highlight = -1
- # Get Text Size
- dummy_formatter = P_Formatter_ATS.new
- lines = (@text + "\x00").scan (/.+?\x00/)
- tw = 32
- for line in lines
- ls, lc, j = dummy_formatter.format_by_line (line, 5000)
- tw1 = 5000 - (ls * (lc - 1))
- tw = tw1 if tw1 > tw
- end
- dummy_formatter.dispose
- if width < 0
- width = [(name ? tw + ($game_message.name_border_size*2) + 4 : tw + 36), 33].max
- end
- super (x, y, width, height)
- self.viewport = viewport
- self.openness = 0
- self.z = 300
- set_stats
- @contents_x, @line_x = 0, 0
- @contents_y = 0
- @contents_width = contents.width
- @align = 0
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Stats
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_stats
- self.windowskin = Cache.system ($game_message.word_windowskin)
- self.opacity = $game_message.word_opacity
- self.back_opacity = $game_message.word_backopacity
- create_back_sprite ($game_message.word_dim, $game_message.word_use_dim)
- self.contents.font.name = $game_message.word_fontname
- self.contents.font.size = $game_message.word_fontsize
- self.contents.font.color = text_color ($game_message.word_fontcolour)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose (*args)
- @back_sprite.bitmap.dispose
- @back_sprite.dispose
- super (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Word
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_word (text = @text, bmp = self.contents)
- @text = text.dup
- loop do
- c = @text.slice!(/./m) # Get next text character
- # Stop when text finished
- break if c.nil?
- if !draw_message_character (c, bmp)
- if c == "\x00"
- @contents_y += @wlh
- @contents_x, @line_x = 0, 0
- set_alignment (@align)
- else
- draw_regular_character (c, bmp)
- end
- end
- end
- end
- end
- #==============================================================================
- # ** Window_NameBox
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This window shows the name
- #==============================================================================
- class Window_NameBox < Window_WordBox
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (name, viewport = nil)
- @word_sprite = Sprite_Base.new (viewport)
- wlh = $game_message.name_wlh > 0 ? $game_message.name_wlh : $game_message.wlh
- rows = (name.scan (/\x00/).size) + 1
- hght = [($game_message.name_border_size*2) + rows*wlh, 33].max
- super (viewport, name, 0, 0, -1, hght, true)
- self.viewport = viewport
- @word_sprite.x, @word_sprite.y = $game_message.name_border_size, $game_message.name_border_size
- @word_sprite.bitmap = Bitmap.new (self.width - (2*$game_message.name_border_size), self.height - (2*$game_message.name_border_size))
- @word_sprite.bitmap.font.name = $game_message.name_fontname
- @word_sprite.bitmap.font.size = $game_message.name_fontsize
- @word_sprite.bitmap.font.color = text_color ($game_message.name_fontcolour)
- @contents_x, @line_x = 2, 2
- draw_word (name, @word_sprite.bitmap)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Stats
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_stats
- self.opacity = $game_message.name_opacity
- self.back_opacity = $game_message.name_backopacity
- create_back_sprite ($game_message.name_dim, $game_message.name_use_dim)
- self.windowskin = Cache.system ($game_message.name_windowskin)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose (*args)
- super (*args)
- @word_sprite.bitmap.dispose
- @word_sprite.dispose
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * X, Y, Z
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- for attr in ["x", "y", "z"]
- ATS_NAMATTR = <<__END__
- def #{attr}= (*args)
- old_val = self.#{attr}
- super (*args)
- diff = self.#{attr} - old_val
- @word_sprite.#{attr} += diff
- end
- __END__
- eval (ATS_NAMATTR)
- end
- end
- #==============================================================================
- # ** Window_FaceBox
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This window processes faces
- #==============================================================================
- class Window_FaceBox < Window_Base
- include Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variables
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- attr_reader :busy
- attr_reader :face_sprites
- attr_accessor :scroll_x
- attr_accessor :scroll_y
- attr_accessor :scroll_x_speed
- attr_accessor :scroll_y_speed
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (viewport)
- @back_sprite = Sprite.new (viewport)
- @face_sprites = []
- @animate_face_count = 0
- @fade_count = 0
- @active_face = 0
- @busy = false
- @scroll_x = 0
- @scroll_y = 0
- @scroll_x_speed = 8
- @scroll_y_speed = 8
- super (0, 0, 128, 128)
- self.viewport = viewport
- self.visible = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Remake Window
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def remake_window (width = $game_message.face_width, height = $game_message.face_height)
- self.width = [width + 2*$game_message.face_border_size, 33].max
- self.height = [height + 2*$game_message.face_border_size, 33].max
- create_contents
- self.windowskin = Cache.system ($game_message.face_windowskin)
- if $game_message.face_fadein
- self.back_opacity = 0
- @fade_count = $game_message.face_opacity
- else
- self.back_opacity = $game_message.face_opacity
- end
- create_back_sprite ($game_message.face_dim, $game_message.face_use_dim)
- self.visible = $game_message.face_window
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose (*args)
- super (*args)
- clear
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Clear
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def clear
- @face_sprites.each { |face| face.dispose } # Dispose all faces
- @face_sprites.clear
- return if self.disposed?
- self.visible = false
- @busy = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def update
- if !@face_sprites.empty? && @face_sprites[@active_face].visible
- # Update Fade In
- if @fade_count > 0
- speed = [$game_message.face_fade_speed, @fade_count].min
- @fade_count -= speed
- self.back_opacity += speed
- @face_sprites.each { |sprite| sprite.opacity += speed }
- end
- # Update Horizontal Scroll
- if @scroll_x != 0
- speed = @scroll_x > 0 ? [@scroll_x_speed, @scroll_x].min : [-1*@scroll_x_speed, @scroll_x].max
- self.x += speed
- @scroll_x -= speed
- end
- # Update Verticaltal Scroll
- if @scroll_y != 0
- speed = @scroll_y > 0 ? [@scroll_y_speed, @scroll_y].min : [-1*@scroll_y_speed, @scroll_y].max
- self.y += speed
- @scroll_y -= speed
- end
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Animate Face
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def animate_face
- if @face_sprites.size > 1
- @face_sprites[@active_face].visible = false
- @animate_face_count = (@animate_face_count + 1) % $game_message.letters_per_face
- @active_face = (@active_face + 1) % @face_sprites.size if @animate_face_count == 0
- @face_sprites[@active_face].visible = true
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Pause Animation
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def pause
- return if @face_sprites.size < 2
- @face_sprites[@active_face].visible = false
- @active_face = 0
- @face_sprites[0].visible = true
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Face
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_face (face_file, index = 0)
- clear
- name = face_file.dup
- loop do
- # Make face and store in @face_sprites unless invalied
- face = Sprite_MessageFace.new (name, index, self.viewport) rescue break
- @face_sprites.push (face)
- break unless $game_message.animate_faces
- # If face_file has a number appended, add all of it's animations
- if name[/\_(\d+)$/i] != nil
- name.sub! (/(\d+)$/) { ($1.to_i + 1).to_s }
- elsif name[/^\!\[(\d+)\]./] != nil # If name has exclamation code
- # Take all animations from the same face file
- index += 1
- break if index == $1.to_i
- else
- break
- end
- end
- @active_face = 0
- @face_sprites[@active_face].visible = true if @face_sprites[@active_face]
- @busy = true
- remake_window
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Goal X; Goal Y : accomodate for scrolling
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def goal_x
- return self.x + @scroll_x
- end
- def goal_y
- return self.y + @scroll_y
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * X=; Y=; Z=
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def x= (value)
- super (value)
- @face_sprites.each { |sprite| sprite.x = self.x + $game_message.face_border_size}
- end
- def y= (value)
- super (value)
- @face_sprites.each { |sprite| sprite.y = self.y + $game_message.face_border_size}
- end
- def z= (value)
- super (value)
- @face_sprites.each { |sprite| sprite.z = self.z }
- end
- end
- #==============================================================================
- # ** Window_ChoiceBox
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This makes a separate window for handling choices, if desired.
- #==============================================================================
- class Window_ChoiceBox < Window_Selectable
- include Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (viewport = nil)
- font = Font.new ($game_message.choice_fontname, $game_message.choice_fontsize)
- @wlh = $game_message.choice_wlh > 0 ? $game_message.choice_wlh : $game_message.wlh
- width, height, line_num = prepare_choices (font.dup)
- @back_sprite = Sprite.new (viewport)
- super (0, 0, width, height)
- if line_num*@wlh > (height - 32)
- self.contents.dispose
- self.contents = Bitmap.new (width - 32, line_num*@wlh)
- end
- self.viewport = viewport
- self.windowskin = Cache.system ($game_message.choice_windowskin)
- self.opacity = $game_message.choice_opacity
- self.back_opacity = $game_message.choice_backopacity
- self.openness = 0
- self.contents.font = font
- self.contents.font.color = text_color ($game_message.choice_fontcolour)
- create_back_sprite ($game_message.choice_dim, $game_message.choice_use_dim)
- @spacing = $game_message.choice_spacing
- @column_max = $game_message.column_max
- @item_max = $game_message.choices.size
- @underline = false
- @highlight = -1
- @last_index = -1
- refresh
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Prepare Choices
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def prepare_choices (font)
- max_width = ($game_message.choice_width > 32 ? $game_message.choice_width : Graphics.width) - 32
- max_width = (max_width - ($game_message.choice_spacing*($game_message.column_max - 1))) / $game_message.column_max
- longest_line = 1
- line_num = 0
- formatter = P_Formatter_ATS.new (font)
- @group_sizes = []
- @choices = []
- group_size = 1
- $game_message.choices.each_index { |i|
- lines = []
- line_sizes = []
- if i % $game_message.column_max == 0
- if i != 0
- line_num += group_size
- @group_sizes.push (group_size)
- end
- group_size = 1
- end
- string = $game_message.choices[i].dup
- while !string.empty?
- ls, lc, j = formatter.format_by_line (string, max_width)
- length = max_width - (ls*(lc - 1))
- string.sub! (/(.*?)\x00/) { "" }
- lines.push ($1.to_s)
- line_sizes.push (length)
- longest_line = [length, longest_line].max
- end
- group_size = [group_size, lines.size].max
- @choices.push ([lines, line_sizes])
- }
- line_num += group_size
- @group_sizes.push (group_size)
- if $game_message.choice_width > 32
- width = $game_message.choice_width
- @line_size = max_width
- else
- width = 36 + ((longest_line + $game_message.choice_spacing)*$game_message.column_max) - $game_message.choice_spacing
- @line_size = longest_line
- end
- height = $game_message.choice_height > 32 ? $game_message.choice_height : 32 + (@wlh*[line_num, $game_message.row_max].min)
- return width, height, line_num
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Refresh
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def refresh
- @choices.each_index { |i|
- @align = 0
- rect = item_rect (i)
- start_x = rect.x
- @contents_y = rect.y
- for j in 0...@choices[i][0].size
- @text = @choices[i][0][j].dup
- length = @choices[i][1][j]
- @contents_x, @line_x = start_x, start_x
- @contents_width = start_x + @line_size
- set_alignment (@align)
- while !@text.empty?
- c = @text.slice! (/./m)
- draw_regular_character (c) if !draw_message_character (c)
- end
- @contents_y += @wlh
- end
- }
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Item Rect
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def item_rect(index)
- rect = super (index)
- rect.y = 0
- for j in 0...(index / $game_message.column_max)
- rect.y += @group_sizes[j]
- end
- rect.y *= @wlh
- rect.height = @group_sizes[index / $game_message.column_max]*@wlh
- return rect
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update Cursor
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def update_cursor
- if @index < 0 # If the cursor position is less than 0
- self.cursor_rect.empty # Empty cursor
- else # If the cursor position is 0 or more
- @help_window.set_text (@index) if @help_window
- return if @index == @last_index
- if $game_message.skip_choices.include? (@index)
- mod = @index - @last_index
- @index = (@index + mod) % $game_message.choice_max
- return
- end
- rect = item_rect(@index) # Get rectangle of selected item
- row = rect.y / @wlh # Get current row
- # Scroll up if before the currently displayed
- self.top_row = row if row < top_row
- # Scroll down if after the currently displayed
- row += (rect.height / @wlh) - 1
- self.bottom_row = row if row > bottom_row
- rect.y -= self.oy # Match rectangle to scroll position
- self.cursor_rect = rect # Refresh cursor rectangle
- @last_index = @index
- end
- end
- end
- #==============================================================================
- # ** Window ChoiceHelp
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # This window shows help text when hovering over choices
- #==============================================================================
- class Window_ChoiceHelp < Window_Base
- include Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def initialize (choice_helps)
- @back_sprite = Sprite.new
- @choice_helps = []
- @underline = false
- @highlight = -1
- font = Font.new ($game_message.choicehelp_fontname, $game_message.choicehelp_fontsize)
- p_formatter = P_Formatter_ATS.new (font)
- longest_line = 1
- x, y = $game_message.choicehelp_x, $game_message.choicehelp_y
- width, height = $game_message.choicehelp_width, $game_message.choicehelp_height
- @wlh = $game_message.choicehelp_wlh < 0 ? $game_message.wlh : $game_message.choicehelp_wlh
- wdth = width > 0 ? width - 32 : 5000
- tallest = 1
- choice_helps.each { |string|
- s_d = $game_message.convert_special_characters (string.dup)
- s_d.gsub! (/\x16/) { "\x00" }
- lines = []
- line_lengths = []
- while !s_d.empty?
- ls, lc, j = p_formatter.format_by_line (s_d, wdth)
- line_lengths.push (wdth - (ls * (lc - 1)))
- lines.push (s_d.slice! (/.*?\x00/))
- end
- tallest = [tallest, lines.size].max
- @choice_helps.push ([lines, line_lengths])
- }
- p_formatter.dispose
- width = line_lengths.max + 32 if width < 0
- x = x >= 0 ? x : [(Graphics.width - width) / 2, 0].max
- y = $game_message.choicehelp_y < 0 ? 0 : $game_message.choicehelp_y
- width = [33, [width, Graphics.width - x].min].max
- height = height < 0 ? 32 + (tallest*@wlh) : [height, 33].max
- super (x, y, width, height)
- @contents_width = contents.width
- self.windowskin = Cache.system ($game_message.choicehelp_windowskin)
- self.opacity = $game_message.choicehelp_opacity
- self.back_opacity = $game_message.choicehelp_backopacity
- self.openness = 0
- create_back_sprite ($game_message.choicehelp_dim, $game_message.choicehelp_use_dim)
- self.contents.font = Font.new ($game_message.choicehelp_fontname, $game_message.choicehelp_fontsize)
- self.contents.font.color = text_color ($game_message.choicehelp_fontcolour)
- @index = -1
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Text
- # index : the index of the choice being highlighted
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_text (index)
- if index != @index
- return if self.disposed?
- contents.clear
- @index = index
- lines = @choice_helps[index][0]
- lengths = @choice_helps[index][1]
- @contents_y = $game_message.choicehelp_center ? (contents.height - (lines.size*@wlh)) / 2 : 0
- @align = 0
- lines.each_index { |i|
- @text = lines[i].dup
- @contents_x, @line_x = 0, 0
- set_alignment (@align)
- while !@text.empty? # Stop when text finished
- c = @text.slice!(/./m) # Get next text character
- draw_regular_character (c) if !draw_message_character (c)
- end
- @contents_y += @wlh
- }
- end
- end
- end
- #==============================================================================
- # ** Window_Gold
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # Make @closing and @opening publicly accessible
- #==============================================================================
- class Window_Gold
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Public Instance Variables
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- attr_reader :closing
- attr_reader :opening
- end
- #==============================================================================
- # ** Window_Message
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # overwritten methods - create_back_sprite; update_message; update_cursor;
- # convert_special_characters; reset_window; draw_face; input_pause; z=;
- # close; visible=
- # aliased methods - initialize; dispose; update; update_show_fast; new_page;
- # start_message; new_line; finish_message; start_choice; terminate_message
- # start_number_input; input_choice
- # new methods - create_namebox; create_wordbox; create_choicebox;
- # create_choicehelp; remake_window; fit_window_to_text; set_position;
- # position_to_character; do_not_obscure_characters; set_face_position;
- # set_speechtag_position; set_name_position; set_choice_position;
- # dispose_ats_windows; update_letter_se; format_line; start_scroll_message;
- # contents_width; draw_message_character; set_alignment
- #==============================================================================
- class Window_Message
- include Window_MessageBase
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats3_win_msg_init_9id1 initialize
- def initialize (viewport = nil, *args)
- @back_sprite = Sprite.new
- modalg_ats3_win_msg_init_9id1 (*args)
- remake_window
- self.viewport = viewport ? viewport : Viewport.new (0, 0, Graphics.width, Graphics.height)
- self.viewport.z = self.z
- @face_window = Window_FaceBox.new (self.viewport)
- @speechtag_sprite = Sprite_SpeechTag.new (self.viewport)
- @longest_line = 0
- @scrolling = 0
- @review_scroll = 0
- @letter_se_count = 0
- @ls = 0
- @underline = false
- @highlight = -1
- @last_index = -1
- @align = 0
- @max_oy = 0
- @p_formatter = P_Formatter_ATS.new (self.contents.font.dup)
- @wlh = $game_message.wlh
- @anti_update = true if self.is_a? (Window_BattleMessage) # Yanfly Melody compatibility measure
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modrna_atxts3_dsps_9th5 dispose
- def dispose (*args)
- modrna_atxts3_dsps_9th5 (*args) # Run Original Method
- dispose_ats_windows
- @face_window.dispose
- @speechtag_sprite.dispose
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias mdrnalg_advtxt3_upd_3xa2 update
- def update (*args)
- # Graphic Novel Support
- if $game_message.graphic_novel && !self.is_a? (Window_BattleMessage)
- if $game_message.gn_press_or_toggle # Press
- self.viewport.visible = !Input.press? ($game_message.hide_button)
- else # Toggle
- self.viewport.visible = !self.viewport.visible if Input.trigger? ($game_message.hide_button)
- end
- return if !self.viewport.visible
- end
- [@choice_window, @choicehelp_window, @word_window, @name_window].each { |window|
- window.update if window && !window.disposed? }
- mdrnalg_advtxt3_upd_3xa2 (*args)
- # If Window opening, but no text and just a choice window.
- if @opening && $game_message.choice_window && @text.empty? && !$game_message.choices.empty?
- close
- $game_message.visible = @closing
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Background Sprite
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_back_sprite
- if @back_sprite
- @back_sprite.bitmap.dispose if @back_sprite.bitmap && !@back_sprite.bitmap.disposed?
- @back_sprite.dispose if !@back_sprite.disposed?
- end
- @back_sprite = Sprite.new (self.viewport)
- bmp = Cache.system($game_message.message_dim)
- @back_sprite.bitmap = Bitmap.new (self.width, self.height + 32)
- @back_sprite.bitmap.stretch_blt (@back_sprite.bitmap.rect, bmp, bmp.rect)
- @back_sprite.visible = (@background == 1)
- @back_sprite.x = self.x
- @back_sprite.y = self.y
- @back_sprite.z = 190
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Namebox
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_namebox (name)
- @name_window.dispose unless @name_window.nil? || @name_window.disposed?
- return if name.empty?
- @name_window = Window_NameBox.new (name, self.viewport)
- @name_window.open
- set_name_position
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Wordbox
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_wordbox (word)
- @word_window.dispose unless @word_window.nil? || @word_window.disposed?
- return if word.empty?
- x = $game_message.word_x
- y = $game_message.word_y == -1 ? @gold_window.y : $game_message.word_y
- @word_window = Window_WordBox.new (self.viewport, word, x, y, $game_message.word_width, $game_message.word_height)
- if $game_message.word_x == -1
- if $game_message.word_y == -1 && (@gold_window.opening || (@gold_window.openness == 255 && !@gold_window.closing))
- @word_window.x = @gold_window.x - @word_window.width
- if @word_window.x < 0
- val = @gold_window.y == 0 ? @gold_window.height : -1*@word_window.height
- @word_window.y += val
- @word_window.x = (Graphics.width - @word_window.width) / 2
- end
- else
- @word_window.x = (Graphics.width - @word_window.width) / 2
- end
- end
- @word_window.draw_word
- @word_window.open
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Choicebox
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_choicebox
- @choice_window = Window_ChoiceBox.new (self.viewport)
- @choice_window.z = self.z + 10
- @choice_window.open
- set_choice_position
- $game_message.choices.clear
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create ChoiceHelp Window
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def create_choicehelp
- @choicehelp_window = Window_ChoiceHelp.new ($game_message.help_choices)
- @choicehelp_window.open
- @choicehelp_window.viewport = self.viewport
- if $game_message.choicehelp_y < 0
- unless Graphics.height - @choicehelp_window.height < self.y + self.height
- @choicehelp_window.y = Graphics.height - @choicehelp_window.height
- end
- end
- @choicehelp_window.z = self.z + 5
- @choice_window.help_window = @choicehelp_window if @choice_window
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Remake Window
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def remake_window (width = $game_message.message_width, height = $game_message.message_height)
- return if width <= 32 || height <= 32
- self.width, self.height = width, height
- self.contents.dispose
- self.contents = Bitmap.new (width - 32, height - 32)
- create_back_sprite
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Fit Window to Text
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def fit_window_to_text
- all_lines = $game_message.texts.dup
- all_lines += $game_message.choices.dup if !$game_message.choice_window
- return if all_lines.size < 1
- @longest_line = 0
- con_hght = [$game_message.max_lines, all_lines.size].min
- $game_message.message_height = 32 + (con_hght*@wlh)
- $game_message.max_lines = con_hght
- # Get Width of longest line
- dummy_formatter = P_Formatter_ATS.new
- all_lines.each { |line|
- c_line = $game_message.convert_special_characters (line.dup)
- ls, lc, j = dummy_formatter.format_by_line (c_line, 5000)
- @longest_line = [@longest_line, (5000 - ls * (lc - 1))].max
- if @longest_line > (Graphics.width - 32)
- @longest_line = Graphics.width - 32
- break
- end
- }
- dummy_formatter.dispose
- $game_message.message_width = 32 + @longest_line
- $game_message.choice_on_line = false if $game_message.message_width + $game_message.choice_width > Graphics.width
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_position (x = $game_message.message_x, y = $game_message.message_y)
- if $game_message.character >= 0
- position_to_character ($game_message.character, $game_message.char_ref)
- self.x = $game_message.message_x
- self.y = $game_message.message_y
- else
- # Set the y position, either directly or by default
- if y == -1
- do_not_obscure_characters if $game_message.do_not_obscure
- self.y = ((Graphics.height - $game_message.message_height) / 2)*@position
- else
- self.y = y
- end
- if self.y < @gold_window.height
- @gold_window.y = Graphics.height - @gold_window.height
- else
- @gold_window.y = 0
- end
- # Set the x position
- if x == -1 # Centre by default
- self.x = (Graphics.width - $game_message.message_width) / 2
- else
- self.x = x
- end
- end
- set_face_position
- set_name_position
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Position To Character
- # character_id : the character around which the message window is to go
- # type : Over, Below, Left or Right of character
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def position_to_character (character_id, type)
- whatever_fits = (type == 4)
- type = 0 if whatever_fits # Above if fits, else Under
- character = character_id == 0 ? $game_player : $game_map.events[character_id]
- # Do not change position if character does not exist
- return if character == nil
- # Do not change position if the character is not on screen.
- return unless character.screen_x.between? (0, Graphics.width) && character.screen_y.between? (0, Graphics.height)
- # Get the size of the character
- bmp = Cache.character (character.character_name).clone
- if character.character_name[/^.?\$/] == nil
- c_wdth, c_hght = bmp.width / 12, bmp.height / 8
- else
- c_wdth, c_hght = bmp.width / 3, bmp.height / 4
- end
- bmp.dispose
- # Centre X or Y depending on position
- if type % 2 == 0
- # Centre X
- x = [character.screen_x - (self.width / 2) , 0].max
- x = (x + self.width <= Graphics.width) ? x : Graphics.width - self.width
- else
- # Centre Y
- y = [character.screen_y - ((self.height + c_hght) / 2), 0].max
- y = (y + self.height <= Graphics.height) ? y : Graphics.height - self.height
- end
- case type
- when 0 # Over
- if whatever_fits && character.screen_y - c_hght - self.height < 0
- position_to_character (character_id, 2)
- return
- end
- y = [character.screen_y - c_hght - self.height, 0].max
- when 1 # Left
- x = [character.screen_x - (c_wdth / 2) - self.width, 0].max
- when 2 # Below
- y = [character.screen_y, Graphics.height - self.height].min
- when 3 # Right
- x = [character.screen_x + (c_wdth / 2), Graphics.width - self.width].min
- end
- $game_message.message_x = x
- $game_message.message_y = y
- if character_id >= 0 && $game_message.speech_tag_index >= 0
- set_speech_sprite_position (character.screen_x, character.screen_y, c_wdth, c_hght, type)
- position_to_character (character_id, 2) if whatever_fits && !@speechtag_sprite.visible
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Do Not Obstruct Characters
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def do_not_obscure_characters
- obscured = [0, 0, 0]
- positions = [2, 0, 1]
- positions.delete (@position)
- positions.unshift (@position)
- positions.each { |pos|
- y = ((Graphics.height - $game_message.message_height) / 2)*pos
- range = y..(y + self.height)
- $game_message.obscure_characters.each { |id|
- char = id == 0 ? $game_player : $game_map.events[id]
- next if char.nil?
- range2 = (char.screen_y - $game_message.obscure_buffer)..char.screen_y
- obscured[pos] += 1 if range === range2.first || range2 === range.first
- }
- if obscured[pos] == 0
- @position = pos
- return
- end
- }
- @position = obscured.index (obscured.min)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Speech Sprite Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_speech_sprite_position (c_x, c_y, c_w, c_h, char_ref)
- @speechtag_sprite.opacity = $game_message.message_opacity
- @speechtag_sprite.set_direction (char_ref)
- @speechtag_sprite.x = c_x - (@speechtag_sprite.width / 2)
- if char_ref == 0
- return if $game_message.message_y < @speechtag_sprite.height - 16
- @speechtag_sprite.y = c_y - c_h - @speechtag_sprite.height
- $game_message.message_y -= (@speechtag_sprite.height - 16)
- @speechtag_sprite.visible = true
- elsif char_ref == 2
- return if $game_message.message_y + (@speechtag_sprite.height - 16) > Graphics.height
- @speechtag_sprite.y = c_y
- $game_message.message_y += @speechtag_sprite.height - 16
- @speechtag_sprite.visible = true
- else
- @speechtag_sprite.visible = false
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Face Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_face_position (x = $game_message.face_x, y = $game_message.face_y)
- return if @face_window.nil? || @face_window.disposed?
- # Determine Goal X
- if x == -1
- if $game_message.face_side
- x = (self.x + 16 - $game_message.face_border_size) + $game_message.face_offset_x
- else
- x = (self.x + self.width - @face_window.width - 16 + $game_message.face_border_size) - $game_message.face_offset_x
- end
- end
- if y == -1
- if @face_window.height < self.height
- y = self.y + ((self.height - @face_window.height) / 2) # Centre
- else
- y = (self.y + self.height) - @face_window.height
- end
- y = self.y if y < 0 # Align to top of window if out of bounds
- y += $game_message.face_offset_y
- end
- # Set up Horizontal Scroll
- if $game_message.face_scroll_x
- left = x + @face_window.width
- right = Graphics.width - x
- if left < right
- @face_window.x = -1*@face_window.width
- @face_window.scroll_x = left
- @face_window.scroll_x_speed = left / $game_message.face_scroll_speed
- else
- @face_window.x = Graphics.width
- @face_window.scroll_x = -1*right
- @face_window.scroll_x_speed = right / $game_message.face_scroll_speed
- end
- else
- @face_window.x = x
- end
- # Set up Vertical Scroll
- if $game_message.face_scroll_y
- up = y + @face_window.height
- down = Graphics.height - y
- if up < down
- @face_window.y = -1*@face_window.height
- @face_window.scroll_y = up
- @face_window.scroll_y_speed = up / $game_message.face_scroll_speed
- else
- @face_window.y = Graphics.height
- @face_window.scroll_y = -1*down
- @face_window.scroll_y_speed = down / $game_message.face_scroll_speed
- end
- else
- @face_window.y = y
- end
- # If there is overlap and meant to fit to text_size
- if $game_message.fit_window_to_text && @longest_line > 0
- con_x, con_w = contents_width (-1)
- $game_message.message_width = @longest_line + contents.width + 32 - con_w
- remake_window
- if self.x + self.width > Graphics.width
- diff = self.x - (Graphics.width - self.width)
- self.x -= diff
- @face_window.x -= diff
- end
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Name Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_name_position (x = $game_message.name_x, y = $game_message.name_y)
- return if @name_window.nil? || @name_window.disposed?
- # Set NameBox coordinates
- if y == -1
- y = self.y - @name_window.height + $game_message.name_offset_y
- y = self.y + self.height - $game_message.name_offset_y if y < 0
- end
- if x == -1
- if $game_message.face_side
- x = self.x + $game_message.name_offset_x
- else
- x = self.x + self.width - @name_window.width - $game_message.name_offset_x
- end
- # If face is showing
- if @face_window.busy
- # If overlap with face
- if ((@face_window.goal_y + $game_message.face_border_size + 1).between? (y, y + @name_window.height) ||
- y.between? (@face_window.goal_y + $game_message.face_border_size + 1, @face_window.goal_y + @face_window.height)) &&
- (x.between? (@face_window.goal_x + $game_message.face_border_size, @face_window.goal_x + @face_window.width) ||
- @face_window.goal_x.between? (x, x + @name_window.width))
- if $game_message.face_side
- x = @face_window.goal_x + @face_window.width
- else
- x = @face_window.goal_x - @name_window.width
- end
- end
- end
- end
- @name_window.x = x
- @name_window.y = y
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Choice Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_choice_position (x = $game_message.choice_x, y = $game_message.choice_y)
- return if @choice_window.nil? || @choice_window.disposed?
- if y == -1
- if self.openness == 0
- y = (Graphics.height - @choice_window.height) / 2
- else
- y = self.y - @choice_window.height + $game_message.choice_offset_y
- y = self.y + self.height - $game_message.choice_offset_y if y < 0
- end
- end
- if x == -1
- choice_side = $game_message.choice_opposite_face ? !$game_message.face_side : $game_message.face_side
- if self.openness == 0
- x = (Graphics.width - @choice_window.width) / 2
- elsif choice_side
- x = self.x - $game_message.choice_offset_x
- else
- x = self.x + self.width - @choice_window.width + $game_message.choice_offset_x
- end
- end
- @choice_window.x = x
- @choice_window.y = y
- @choice_window.y = self.y if $game_message.choice_on_line
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Dispose Windows
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def dispose_ats_windows
- ats_windows = [@name_window, @word_window, @choice_window, @choicehelp_window]
- ats_windows.each { |window| window.dispose unless window.nil? || window.disposed? }
- @name_window = nil
- @word_window = nil
- @choice_window = nil
- @choicehelp_window = nil
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update Show Fast
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias mrnagb_atsys3_updshfst_6yv3 update_show_fast
- def update_show_fast (*args)
- real_count = @wait_count
- @wait_count = 2 if $game_message.skip_disabled
- mrnagb_atsys3_updshfst_6yv3 (*args) # Run Original Method
- @wait_count = real_count
- @face_window.update
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def update_message
- loop do
- if @scrolling > 0
- speed = [$game_message.scroll_speed, @scrolling].min
- @scrolling -= speed
- self.oy += speed
- if @scrolling <= 0 && self.contents.height < self.oy + self.height - 32
- bmp = self.contents
- # Max # of lines before cutting top out approx. 200
- if self.contents.width * (self.oy + self.height - 32) < 2500000
- self.contents = Bitmap.new (self.contents.width, self.oy + self.height - 32)
- self.contents.font = bmp.font.dup
- src_rect = bmp.rect
- else
- src_rect = Rect.new (0, @wlh, bmp.rect.width, bmp.rect.height - @wlh)
- end
- self.contents.blt (0, 0, bmp, src_rect)
- bmp.dispose if src_rect.y != 0
- end
- break
- end
- c = @text.slice!(/./m) # Get next text character
- # If no text left
- if c.nil?
- if @choice_sizes
- @choice_sizes[-1].push (@line_count - @choice_sizes[-1][0])
- end
- if $game_message.choices.empty?
- $game_message.choice_start = @choice_sizes[0][0] if @choice_sizes
- finish_message # Finish update
- break
- else
- if @choice_sizes.nil?
- $game_message.scroll_by_page = false
- if $game_message.choice_window
- create_choicebox
- finish_message
- return
- end
- if !$game_message.scrolling
- if $game_message.max_lines < @line_count + $game_message.choices.size
- self.pause = true
- $game_message.choice_start = 0
- @text = "\x1d"
- end
- $game_message.scrolling = true
- return
- end
- @choice_sizes = []
- end
- @text = "#{$game_message.choices.shift}\x00"
- # New line stuff
- format_line
- @choice_sizes.push ([@line_count])
- c = @text.slice!(/./m) # Get next text character
- end
- end
- draw_message_character (c)
- break unless @show_fast || @line_show_fast || $game_message.message_speed < 0
- break if self.pause
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update Letter SE
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def update_letter_se
- return if !$game_message.letter_sound || @show_fast || @line_show_fast ||
- $game_message.message_speed < 0
- # Randomize Pitch
- rp = $game_message.random_pitch
- $game_message.letter_se.pitch = rp.first + rand(rp.last - rp.first) unless rp.first == rp.last
- # Update Sound
- $game_message.play_se ($game_message.letter_se) if @letter_se_count == 0
- @letter_se_count = (@letter_se_count + 1) % $game_message.letters_per_se
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Update cursor
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def update_cursor
- return if @choice_window
- if @index >= 0
- @choicehelp_window.set_text (@index) if @choicehelp_window
- return if @index == @last_index
- if $game_message.skip_choices.include? (@index)
- mod = @last_index < @index ? 1 : -1
- @index = (@index + mod) % $game_message.choice_max
- return
- end
- row = @choice_sizes[@index][0]
- hght = @choice_sizes[@index][1]*@wlh
- y = (row) * @wlh
- x, con_width = contents_width (self.contents.height > self.height - 32 ? -1 : y)
- # Scroll up if before the currently displayed
- self.top_row = row if row < top_row
- row += @choice_sizes[@index][1] - 1
- # Scroll down if after the currently displayed
- self.bottom_row = row if row > bottom_row
- self.cursor_rect.set(x, y - self.oy, con_width, hght)
- @last_index = @index
- else
- self.cursor_rect.empty
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Start Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malg_atxs3_msgstrt_8ik3 start_message
- def start_message (*args)
- @starting = true
- @wlh = $game_message.wlh
- @align = 0
- @max_oy = 0
- @line_x = 0
- @underline = $game_message.underline
- @highlight = $game_message.highlight
- malg_atxs3_msgstrt_8ik3 (*args)
- @text.gsub! (/([^\s])\s*\x00/) { "#{$1} " } if $game_message.paragraph_format
- # Remove x00 from middle of wb and nb boxes
- @text.gsub! (/[\x19\x1a]{.*?}/) { |match| match.gsub (/\x00/) { "" } }
- @text.gsub! (/\x16/) { "\x00" }
- format_line
- self.windowskin = Cache.system ($game_message.message_windowskin).dup
- self.windowskin.clear_rect (80, 16, 32, 32) unless $game_message.scroll_show_arrows
- self.contents.font.name = $game_message.message_fontname
- self.contents.font.size = $game_message.message_fontsize
- @p_formatter.bitmap.font = self.contents.font.dup
- $game_message.play_se ($game_message.start_se) if $game_message.start_sound
- @starting = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * New Page
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malba_advts3_nwpge_7uj2 new_page
- def new_page (*args)
- if !$game_message.do_not_start || !@starting
- if @text.sub! (/\A\x17<(\d+)>/, "") != nil
- actor = $game_actors[$1.to_i]
- if !actor.nil?
- $game_message.face_name = actor.face_name
- $game_message.face_index = actor.face_index
- end
- end
- @face_window.clear if !@face_window.nil? && !@face_window.disposed?
- malba_advts3_nwpge_7uj2 (*args) # Run Original Method
- self.contents.font.color = text_color ($game_message.message_fontcolour)
- self.contents.font.color.alpha = $game_message.message_fontalpha if $game_message.message_fontalpha != 255
- self.oy = 0
- elsif (@line_count - (self.oy / @wlh)) >= $game_message.max_lines
- # If scrolling
- start_scroll_message if $game_message.scrolling
- end
- @contents_x, @contents_width = contents_width
- @line_x = @contents_x
- unless @starting
- @text.sub! ("\x00", " ") if @text && $game_message.paragraph_format && !(@p_formatter && @p_formatter.force_break)
- format_line
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * New Line
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats3_nl_scroll_0ol2 new_line
- def new_line (*args)
- modalg_ats3_nl_scroll_0ol2 (*args)
- @contents_y = @line_count*@wlh
- @contents_x, @contents_width = contents_width (@contents_y)
- @line_x = @contents_x
- format_line
- # If Reached end of page
- if (@line_count - (self.oy / @wlh)) >= $game_message.max_lines
- # Do not pause if message is over
- return if @text == "" && ($game_message.choices.empty? || $game_message.choice_window)
- # If scrolling
- if $game_message.scrolling
- start_scroll_message
- else
- self.pause = true
- end
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Format Line
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def format_line
- if $game_message.paragraph_format
- @ls, dc, justify = @p_formatter.format_by_line (@text, @contents_width)
- else
- @ls = 0
- end
- set_alignment (@align) if @align != 0
- @ls = 0 if @ls > 0 && (!justify || @align != 0)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Convert Special Characters
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def convert_special_characters
- $game_message.convert_special_characters (@text)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Window Background and Position
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def reset_window
- @background = $game_message.background
- @position = $game_message.position
- $game_message.choice_on_line = false if $game_message.choice_width < 32
- fit_window_to_text if $game_message.fit_window_to_text
- if $game_message.choice_window && $game_message.choice_on_line
- $game_message.message_width = [$game_message.message_width, Graphics.width - $game_message.choice_width].min
- total_width = $game_message.message_width + $game_message.choice_width
- if $game_message.message_x == -1
- $game_message.message_x = (Graphics.width - total_width) / 2
- elsif $game_message.message_x + total_width > Graphics.width
- $game_message.message_x = Graphics.width - total_width
- end
- choice_side = $game_message.choice_opposite_face ? !$game_message.face_side : $game_message.face_side
- if choice_side
- $game_message.choice_x = $game_message.message_x
- $game_message.message_x += $game_message.choice_width
- else
- $game_message.choice_x = $game_message.message_x + $game_message.message_width
- end
- $game_message.choice_height = $game_message.message_height
- end
- remake_window unless $game_message.do_not_start
- # Set opacity
- self.opacity = @background == 0 ? $game_message.message_opacity : 0
- self.back_opacity = $game_message.message_backopacity
- # Remake speech bubble if different
- @speechtag_sprite.reset_graphic
- @speechtag_sprite.z = self.z + 1
- if @text.include? ("\x1c")
- @text = ""
- self.openness = 0 unless $game_message.do_not_refresh
- end
- set_position
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Finish Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malbra_ats3_fnmsg_7uj2 finish_message
- def finish_message (*args)
- @face_window.pause
- $game_message.play_se ($game_message.finish_se) if $game_message.finish_sound
- malbra_ats3_fnmsg_7uj2 (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Start Choices
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modrn_ats3_strtchc_5sf2 start_choice
- def start_choice (*args)
- modrn_ats3_strtchc_5sf2 (*args)
- $game_message.move_when_visible = false
- if @choice_window
- self.index = -1
- @choice_window.index = 0
- end
- create_choicehelp if !$game_message.help_choices.empty?
- @max_oy = [(@line_count - $game_message.max_lines)*@wlh, 0].max
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Start Number Input
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malgr_advts3_strtnuminp_8qw2 start_number_input
- def start_number_input (*args)
- malgr_advts3_strtnuminp_8qw2 (*args) # Run Original Method
- if $game_message.scrolling
- self.oy += @wlh if @line_count >= $game_message.max_lines
- @number_input_window.y -= self.oy
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Start Scroll Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def start_scroll_message
- scroll_plus = @wlh
- scroll_plus *= $game_message.max_lines if $game_message.scroll_by_page
- @scrolling += scroll_plus
- @show_fast = false
- if $game_message.scroll_autopause && !@text.nil? && !@text.empty?
- self.pause = true
- $game_message.play_se ($game_message.pause_se) if $game_message.pause_sound
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * End Message
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modal_atsv3_trmmsg_8yx4 terminate_message
- def terminate_message (*args)
- if !$game_message.do_not_refresh
- if !@face_window.nil? && !@face_window.disposed?
- if self.is_a? (Window_BattleMessage)
- @face_window.visible = false
- @face_window.clear
- create_contents if contents.height > height - 32
- self.oy = 0
- end
- end
- dispose_ats_windows
- else
- @choice_window.dispose if @choice_window && !@choice_window.disposed?
- @choicehelp_window.dispose if @choicehelp_window && !@choicehelp_window.disposed?
- @choice_window = nil
- @choicehelp_window = nil
- end
- $game_message.play_se ($game_message.terminate_se) if $game_message.terminate_sound
- modal_atsv3_trmmsg_8yx4 (*args) # Run Original Method
- @last_index = -1
- @choice_sizes = nil
- @speechtag_sprite.visible = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Contents Width
- # y : the line to check it on
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def contents_width (y = 0)
- # If can scroll, make sure no overlap over whole range. Get the ranges
- if y < 0 || ($game_message.scrolling && $game_message.texts.size > $game_message.max_lines)
- m_range = (self.y + 16)..(self.y + 16 + ($game_message.max_lines*@wlh))
- else
- screen_y = self.y + 16 + y - self.oy
- m_range = screen_y..screen_y + @wlh
- end
- return 0, contents.width if @face_window.z < self.z
- f_range = @face_window.goal_y..(@face_window.goal_y + @face_window.height)
- # If there is overlap with the face window
- if @face_window.busy && (m_range === f_range.first || f_range === m_range.first)
- left = @face_window.goal_x - (self.x + 20)
- right = self.x + self.width - 20 - (@face_window.goal_x + @face_window.width)
- if left >= right
- return 0, left
- else
- return @face_window.goal_x + @face_window.width - (self.x + 12), right
- end
- end
- return 0, contents.width # Start X, total width
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Face
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_face (face_file, face_index, *args)
- @face_window.set_face (face_file, face_index)
- set_face_position
- @face_window.z = self.z + $game_message.face_z
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Message Character
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_message_character (c)
- return if super (c)
- case c
- when "\x00" # New line
- new_line
- when "\x02" # \G (gold display)
- @gold_window.refresh
- @gold_window.openness > 0 ? @gold_window.close : @gold_window.open
- when "\x03" # \W[x] (Wait x frames)
- @text.sub!(/<(\d+)>/, "")
- @wait_count = $1.to_i
- @face_window.pause
- @show_fast, @line_show_fast = false, false
- when "\x04" # \! (Wait for input)
- self.pause = true
- $game_message.play_se ($game_message.pause_se) if $game_message.pause_sound
- @show_fast, @line_show_fast = false, false
- when "\x05" # \/@ (Fast display ON)
- @text.sub!(/<([01])>/, "")
- @line_show_fast = (Game_ATS::ATS_2 && $1.to_i == 0) ? !@line_show_fast: $1.to_i == 0
- when "\x06" # \/@@ (Fast display OFF)
- @text.sub!(/<([01])>/, "")
- @show_fast = (Game_ATS::ATS_2 && $1.to_i == 0) ? !@show_fast : $1.to_i == 0
- when "\x07" # \^ (No wait for input)
- @pause_skip = true
- when "\x08" # Speed Change
- @text.sub!(/<(=?-?\d+)>/, "")
- s = $1.to_s
- s.sub! (/(=)/, "")
- if $1.nil?
- $game_message.message_speed = [$game_message.message_speed + s.to_i, -1].max
- else
- $game_message.message_speed = [s.to_i, -1].max
- end
- when "\x0b" # Show Animation
- # Extract Target and Graphic ID
- @text.sub! (/<(\d*),(\d*),([01])>/, "")
- return if self.is_a? (Window_BattleMessage)
- char = $1.to_i < 1 ? $game_player : $game_map.events[$1.to_i] # Target
- if char != nil
- $3.to_i == 0 ? char.animation_id = $2.to_i : char.balloon_id = $2.to_i
- end
- when "\x0c" # Position to Character
- @text.sub! (/<(\d+),([0-4])>/, "")
- return if self.is_a? (Window_BattleMessage)
- $game_message.character = $1.to_i
- $game_message.char_ref = $2.to_i
- set_position
- new_page
- when "\x17" # Use Actor Face
- @text.sub! (/<(\d+)>/, "")
- $game_message.face_name = $game_actors[$1.to_i].face_name
- $game_message.face_index = $game_actors[$1.to_i].face_index
- draw_face ($game_message.face_name, $game_message.face_index)
- set_name_position
- when "\x19" # Name Box
- @text.sub! (/{(.*?)}/, "")
- create_namebox ($1.to_s)
- when "\x1a" # Word Box
- @text.sub! (/{(.*?)}/, "")
- create_wordbox ($1.to_s)
- when "\x1b" # Play SE
- @text.sub! (/<(.+?),([MS]E)>/, "")
- $game_message.play_se ((RPG.const_get ($2.to_s)).new ($1.to_s))
- when "\x1d" # New Page
- create_contents
- new_page
- when "\x1f" # Position setting
- @text.sub! (/<([012]),(-?\d+),(-?\d+)>/, "" )
- return if self.is_a? (Window_BattleMessage)
- case $1.to_i
- when 0 then set_position ($2.to_i, $3.to_i)
- when 1 then set_face_position ($2.to_i, $3.to_i)
- when 2 then set_name_position ($2.to_i, $3.to_i)
- end
- new_page unless $1.to_i == 2
- when "\x7f" # Evaluate Code
- @text.sub! (/\{(.+?)#\}/, "")
- eval ($1.to_s)
- when "\xb0" # Enable/Disable Skipping
- @text.sub!(/<([01])>/, "")
- $game_message.skip_disabled = (Game_ATS::ATS_2 && $1.to_i == 0) ? !$game_message.skip_disabled : $1.to_i == 0
- @show_fast, @line_show_fast = false, false
- when "\xb1" # Set Contents X
- start_x, throwaway = contents_width (@contents_y)
- @contents_x += start_x
- else # Normal text character
- draw_regular_character (c)
- @wait_count += $game_message.message_speed if !@show_fast &&
- !@line_show_fast && $game_message.message_speed > 0
- update_letter_se
- @face_window.animate_face
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Set Alignment
- # align : The alignment ( 1 => Centre, 2 => Right )
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def set_alignment (align = 1)
- # Get rest of line
- formatter = P_Formatter_ATS.new (self.contents.font.dup)
- txt = @text[/.*?\x00/]
- txt = "" if txt.nil?
- ls, lc, j = formatter.format_by_line (txt, @line_x + @contents_width - @contents_x)
- formatter.dispose
- es = ls * (lc - 1)
- @contents_x += (es / 2)*align
- @ls = 0 if align > 0
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Input Pause
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def input_pause (*args)
- # Allow to review message before inputting
- if $game_message.scroll_review
- if @review_scroll != 0
- scroll_plus = @review_scroll > 0 ? [@review_scroll, $game_message.scroll_speed].min :
- [@review_scroll, -1*$game_message.scroll_speed].max
- self.oy += scroll_plus
- self.oy = [[self.oy, 0].max, @max_oy].min
- @review_scroll -= scroll_plus
- end
- if Input.press? (Input::UP)
- @review_scroll -= $game_message.scroll_speed
- elsif Input.press? (Input::DOWN)
- @review_scroll += $game_message.scroll_speed
- end
- end
- # Original Method
- if Input.trigger?(Input::B) or Input.trigger?(Input::C)
- self.oy = @max_oy
- self.pause = false
- if @text != nil and not @text.empty?
- new_page if !$game_message.scrolling && @line_count >= $game_message.max_lines
- else
- terminate_message
- end
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Choice Input
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modab_ats3_inptchc_7yh2 input_choice
- def input_choice (*args)
- if Input.trigger?(Input::C)
- indx = @choice_window ? @choice_window.index : self.index
- if $game_message.disabled_choices.include? (indx)
- Sound.play_buzzer
- else
- Sound.play_decision
- $game_message.choice_proc.call(indx)
- terminate_message
- end
- return
- end
- modab_ats3_inptchc_7yh2 (*args)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Pause=
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias malabra_ats3_setpause_8uj2 pause= unless self.method_defined? (:malabra_ats3_setpause_8uj2)
- def pause= (boolean)
- malabra_ats3_setpause_8uj2 (boolean)
- if boolean
- @max_oy = self.oy
- @face_window.pause
- end
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Z=
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def z= (*args)
- diff = -1*self.z
- super (*args)
- diff += self.z
- ats_gfx = [@face_window, @name_window, @word_window, @speechtag_sprite,
- @back_sprite, @choice_window, @choicehelp_window]
- ats_gfx.each { |gfx| gfx.z += diff unless gfx.nil? }
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Visible =
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def visible= (boolean)
- super (boolean)
- @face_window.clear if @face_window && !@face_window.disposed? && !boolean
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Close
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def close (*args)
- super (*args)
- if !@face_window.nil? && !@face_window.disposed?
- @face_window.clear
- @face_window.close
- end
- @name_window.close if @name_window && !@name_window.disposed?
- end
- end
- #==============================================================================
- # ** Window_BattleMessage
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # aliased method - initialize
- # overwritten method - draw_line
- #==============================================================================
- class Window_BattleMessage
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Object Initialization
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modrna_ynfl_melatscomp_5yh2 initialize
- def initialize (*args) # Yanfly Melody compatibility measure
- modrna_ynfl_melatscomp_5yh2 (*args)
- @anti_update = false
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Draw Line
- # index : the line to draw on
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- def draw_line(index)
- return if !@text.nil?
- rect = Rect.new(0, 0, 0, 0)
- rect.x += 4
- rect.y += index * @wlh
- rect.width = contents.width - 8
- rect.height = @wlh
- self.contents.clear_rect(rect)
- self.contents.font.color = normal_color
- @wlh = $game_message.battle_wlh
- @text = @lines[index].dup
- convert_special_characters
- @contents_x = rect.x
- @contents_y = rect.y
- loop do
- c = @text.slice!(/./m) # Get next text character
- # Stop when text finished
- break if c.nil?
- draw_message_character (c)
- end
- @text = nil
- end
- end
- #==============================================================================
- # ** Scene_Title
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # aliased method - create_game_objects
- #==============================================================================
- class Scene_Title
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Create Game Objects
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats3_gm_obj_create create_game_objects
- def create_game_objects (*args)
- # Create the object which holds default values for message
- $game_ats = $ats_default = Game_ATS.new
- # Run original method
- modalg_ats3_gm_obj_create (*args)
- end
- end
- #==============================================================================
- # ** Scene_File
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Summary of Changes:
- # aliased methods - write_save_data; read_save_data
- #==============================================================================
- class Scene_File
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Write Save Data
- # file : the file being written to
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats3_write_save write_save_data
- def write_save_data (file, *args)
- # Run Original Method
- modalg_ats3_write_save (file, *args)
- Marshal.dump($game_ats, file)
- end
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- # * Read Save Data
- # file : the file being read from
- #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- alias modalg_ats3_read_save_data read_save_data
- def read_save_data (file, *args)
- # Run Original Method
- modalg_ats3_read_save_data (file, *args)
- begin
- $game_ats = $ats_default = Marshal.load (file)
- rescue # Initialize if old save
- $game_ats = $ats_default = Game_ATS.new
- $game_message.clear
- end
- end
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement