Note Manager

This script provides various note-tagging functionality. It implements the “Note Files” specification. It supports the following features

• Automatically loading external notes stored in text files
• Note Sections
• Explicitly loading external note files from your note box

This script adds functionality for handling external Note Files which are associated with an object.

It also adds Note Sections to your notes, allowing you to partition your note into different sections and quickly retrieve a block of text inside the notebox without having to parse the entire note yourself.

This scripts provides external note files for all objects that originally supported note boxes, as well as the following objects

-Enemy Drops
-Enemy Actions
-Troops
-Animations
-Map Events
-Map Event Pages

External note files allow you to manage all extra notes in an organized fashion.

This script should be placed above custom materials.

Download

Script: download here

Usage

Using Note Files

Many objects now have a note field, which you can manage using the built-in note boxes, or  alternatively an external note file.

After testplaying your project for the first time, you should go to your Data folder and see a new Notes folder. Many folders will be created inside this Notes folder, and they should correspond to the different objects in your project.

All of the note files are named based on the ID of the object. You can open the text files in any text editor, and tag them the same way you would tag a note box.

Events note files are stored inside their map folder.
Event pages are stored with their events, indicated by the page number.

Note Tagging

Suppose you wanted to add a note to the first drop of your enemy. You would begin by creating a note section in the enemy’s note box

<note: drop_item 1>
</note>

The 1 means you are adding this to the first drop item.
Now you want to actually do something with the note, as you would with any other note parsing.
You will alias the load_notetag method defined for drop items

class RPG::Enemy::DropItem

  alias: th_load_notetag :load_notetag
  def load_notetag
        p "Hi, it works"
        th_load_notetag
  end
end

And this is basically how you would tag drop items. The same applies for enemy actions

<note: action 2>
   your note
</note>

This will create a note for the second action.

Storing your notes in external files

This script supports external note files that are referenced in an object’s note box.

You can have multiple external note references in a single note box.
Use the following tag:

<note_src: PATH>
<note_src: PATH2>

All notes are located at “Data/Notes”, and supports subfolders.

This applies to note sections as well. So for example if I wanted to add a new drop item to my slime, and I decided to store it in an external note whose path is “Data/Notes/Enemies/Slime/drops.txt”, I would tag the drop section with

<note: drop_item 5>
  <note_src: Enemies/Slime/drops.txt>
</note>

Defining your own note sections

This script also provides functionality for developers that wish to define their own note sections. Actually, there isn’t much to it.

Suppose you asked your users to tag their note box with

<note: your_custom_section args*>
   your note
</note>

You can retrieve this section using

obj.note_sections(:your_custom_section)

Where obj is some RPG::BaseItem object such as an actor, enemy, item, …

This will return an array of NoteSection objects, which stores the name of the section, any extra arguments (as a string), as well as the note for the section, as defined below

class NoteSection

  attr_accessor :name            # the name of this section
  attr_accessor :ex_data          # extra data that you might need, as a string
  attr_accessor :note            # the contents of the note

  def initialize(name, note, data="")
        @name = name
        @ex_data = data.strip
        @note = note.strip
  end
end

You can decide how you want to work with this data. I don’t have any ideas beyond enemy drop items and enemy actions so I can’t give much help here.