Permalink
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
2065 lines (2028 sloc) 102 KB
#==============================================================================
# Event Printer - RPG Maker VXace
#------------------------------------------------------------------------------
# Version 1.3.1 - 06/05/2015
# - Add class 'event_code' to HTML and BBcode outputs
# Version 1.3 - 04/11/2013
# - Bugfix on conditions variable - variable. Second variable wasn't the good one
# Version 1.2 - 18/05/2013
# - Changes to BBcode/HTML (for BilouCorp)
# Version 1.1 - 25/04/2013
# - Bugfix
# - BBcode is now 100% BBcode (Thanks to Joke - Biloucorp)
# Version 1.0 - 23/04/2013
# - Original Release VXace
#------------------------------------------------------------------------------
# Special thanks to Nuki, Grim (and the other members of Funkywork)
#------------------------------------------------------------------------------
# This system is designed to transform en event from RPG maker to a textual representation
# Two type of output are usable. You can chose to print it in a file or you can put this into your clipboard
# Three output format are available : raw (only text), BBcode and HTML.
#
# You can change colors into the Theme module
# Only accessible in test mode.
#------------------------------------------------------------------------------
# - How to use depending your level :
# - Newbie Just launch SceneManager.call(EventPrinter::Scene) or press F5 on title screen
#
# - Programmer You can build event with the build method EventPrinter::Event / CommonEvent / BattleEvent
# Example : EventPrinter::CommonEvent.build(id_event, id_map)
# (you always need a map id (reference to event names)
# Then you can use print_raw, print_bbcode, print_html, copy_raw, copy_bbcode, copy_html
#
# - Nuki No. Don't use this Nuki
#==============================================================================
if $TEST
module EventPrinter
#==============================================================================
# ** Theme module
#==============================================================================
module Theme
#--------------------------------------------------------------------------
# ** Get a certain color
#--------------------------------------------------------------------------
def self.get_color(color)
self.const_get(color.to_s.capitalize.intern)
end
#---------------------------------------------------------------------------------------------
# * Color constants
#---------------------------------------------------------------------------------------------
Nothing = "#FFFFFF"
Standard = "#000000"
Function = "#0000FF"
Events = "#800000"
Comments = "#00A000"
Musics = "#008080"
Battle = "#9000D0"
Game = "#2090FF"
Parameters = "#A0A0A0"
Text = "#000080"
Variables = "#FF0000"
Pictures = "#800080"
Manage = "#DC6E00"
System = "#FF00FF"
Script = "#808080"
Graphics = "#FF00A0"
Wait = "#C03000"
end
# End of Theme ------------------------------------------------------------------------------------------------
#==============================================================================
# ** Vocab module
#==============================================================================
module Vocab
#--------------------------------------------------------------------------
# Commands Vocab
#--------------------------------------------------------------------------
# Misc
Name = "[%s]"
Group = "%04d..%04d"
VariableName = "%04d:%s"
MoreOrLess = ["ou plus", "ou moins"]
Command = "| >"
Vehicle = ["Radeau", "Bateau", "Vaisseau"]
Operators = ["=", "+=", "-=", "*=", "/=", "%="]
Wait = "Attendre : %d Frames"
SwitchOnOff = ["Désactiver", "Activer"]
WaitEnd = ", Attendre"
# Battlers
Attributes = ["Niveau", "Expérience", "PV", "PM", "PV Maximum", "PM Maximum",
"Attaque", "Défense", "Magie", "Déf. Magique", "Agilité", "Chance"]
# Evenements
HeroEvent = "Héros"
ThisEvent = "Cet événement"
# Dialogues
Message = "Message :"
MessageParams = "%s, %s, %s, %s"
MessagePosition = ["Bas", "Milleu", "Haut"]
MessageDisplay = ["Normal", "Transparent", "Sombre"]
Void = "Ø"
Choices = "Afficher Choix :"
Choice = "Si %s - Faire"
CancelChoice = "Annulation"
EndChoice = "Fin - Choix"
GetVar = "Entrer un Nombre - Stocker dans la variable %s, %d Chiffre(s)"
SelectItem = "Sélection d'un objet : %s"
DisplayScrollingText = "Afficher un texte défilant :"
ScrollSpeed = "Vitesse %d"
DisableFastForward = ", Désactiver l'avance rapide"
# Operations on variables
Operation = "Opération :"
Switch = "Interrupteur"
LocalSwitch = "Interrupteur local"
OnOff = ["Activé", "Désactivé"]
Variable = "Variable"
ValueOfVariable = "(la valeur de la variable %s)"
RandomValue = "(valeur aléatoire entre %d et %d)"
NumberOf = "%s possédés"
EventParam = ["Coordonée X", "Coordonée Y", "Direction", "Coordonée X à l'écran", "Coordonée Y à l'écran"]
OtherVariable = ["ID de la carte", "Nombre de personnage dans l'équipe", "Argent possédé",
"Nombre total de pas", "Temps de jeu", "Chronomètre", "Nombre de sauvegardes", "Nombre de combats"]
IdOfAMember = "ID du %s membre"
OrdinalNumber = ["1er", "2ème", "3ème", "4ème", "5ème", "6ème", "7ème", "8ème"]
Chronometer = "Gestion du Chronomètre :"
LeChronometer = "le Chronomètre est"
Time = "à %d Minutes et %d Secondes"
Start = "Démarrer (" + Time + ")"
Stop = "Arrêter"
# Conditions
Condition = "Condition :"
ComparationOperator = ["==", ">=", "<=", ">", "<", "!="]
HeroConditions = ["est dans l'équipe", "a pour nom '%s'", "a comme classe %s", "a la compétence %s",
"est équipé avec l'arme %s", "est équipé avec l'armure %s", "est sous l'effet de statut %s"]
MoneyCondition = "l'argent possédé est de %d %s"
ItemCondition = "l'objet %s est possédé"
WeaponCondition = "l'arme %s est possédée%s"
ArmorCondition = "l'armure %s est possédée%s"
OrEquipped = ", ou équipée"
KeyCondition = "la touche %s est pressée"
VehicleCondition = "le véhicule [%s] est utilisé"
Present = "est présent"
ScriptCondition = "Script : %s"
Else = "Sinon"
EndCondition = "Fin - Condition"
# Functions
CommonEventCall = "Appeler Événement Commun :"
Loop = "Boucle"
EndLoop = "Fin - Boucle"
ExitLoop = "Sortir de la Boucle"
Goto = "Étiquette :"
GotoCall = "Aller à l'Étiquette :"
StopEvents = "Arrêter les évènements"
Comment = "Commentaire :"
# Music / Video
Music = "'%s', Volume : %d, Tempo : %d"
BGM = "Jouer BGM :"
MemorizeBGM = "Mémoriser la musique (BGM)"
RestartBGM = "Reprendre la musique (BGM)"
BGS = "Jouer BGS :"
ME = "Jouer ME :"
SE = "Jouer SE :"
StopBGM = "Arrêter en fondu de la BGM : %s Secondes"
StopBGS = "Arrêter en fondu du BGS : %s Secondes"
StopSE = "Arrêter SE"
PlayVideo = "Jouer une vidéo : '%s'"
# Battle
Battle = "Démarrer un combat : %s"
BattleIndexed = "(Indexé par [%04d])"
IfVictory = "Si Victoire - Faire"
IfFlee = "Si Fuite - Faire"
IfLoss = "Si Défaite - Faire"
EndBattle = "Fin - Combat"
AllEnemies = "Tous les ennemis"
Enemy = "[%d. %s]"
# Game
Shop = "Appeler magasin :"
EnterName = "Enter le nom d'un personnage : %s, %d Lettres"
OpenMenu = "Ouvrir le menu principal"
OpenSave = "Ouvrir le menu de sauvegarde"
GameOver = "Game Over"
ToTitle = "Retourner à l'écran titre"
# System
ModifyBGM = "Modifier BGM de combat :"
ModifyME = "Modifier ME de victoire :"
ModifiySave = "Modifier l'accès aux sauvegardes :"
ModifiyMenu = "Modifier l'accès au menu :"
ModifiyEncounter = "Modifier les rencontres :"
ModifiyFormation = "Formation de l'équipe :"
WindowColor = "Affichage du nom de la carte : %s"
ModifyHeroAppearance = "Modifier Apparence Personnage : %s, Charset:'%s', 0, Faceset:'%s', 0"
ModifyVehicleAppearance = "Modifier Apparence Véhicule : [%s], '%s', 0"
# Script
ScriptCall = "Appeler Script :"
# Manage
WholeTeam = "Équipe Entière"
ModifyMoney = "Modifier Argent :"
ModifyItem = "Modifier Objet :"
ModifyWeapon = "Modifier Armes :"
ModifyArmor = "Modifier Armures :"
ModifyParty = "Modifier l'équipe :"
ModifyTextWithIncluded = "%s, Inclure l'équipement"
ModifyPartyTextWithReset = "%s, Démarre au niveau initial"
ModifyHP = "Modifier PV :"
ModifyMP = "Modifier PM :"
ModifyStatus = "Modifier Status : %s,"
Recover = "Récupération complète :"
ModifyExperience = "Modifier Expérience : %s,"
ModifyLevel = "Modifier Niveau : %s,"
ModifyParameters = "Modifier Caractéristique : %s,"
ModifySkill = "Modifier Compétence : %s,"
ModifyEquipement = "Modifier Équipement : %s,"
ModifyHeroName = "Modifier Nom Personnnage : %s,"
ModifyHeroAlias = "Modifier Surnom Personnnage : %s,"
ModifyHeroClass = "Modifier Classe Personnage : %s,"
RestoreEnemy = "Récupération Complète - "
PlusOrMinus = ["+", "-"]
AddOrRemove = ["Ajouter", "Retirer"]
Equipement = ["Armes", "Bouclier", "Casque", "Armure", "Accessoire"]
# Battle
ModifyHPEnemy = "Modifier PV - Ennemi : %s,"
ModifyMPEnemy = "Modifier PM - Ennemi : %s,"
ModifyStatusEnemy = "Modifier Status - Ennemi : %s,"
RecoverEnemy = "Récupération Complète - Ennemi : %s"
RevealEnemy = "Apparition ennemi caché : %s"
MorphEnemy = "Transformer l'ennemi : %s en %s"
DisplayBattleAnimation = "Afficher animation de combat : %s,"
Battler = "Personnage n°%d"
LastTarget = "Dernière Cible"
RandomTarget = "Cible Aléatoire"
Target = "Cible n°%d"
ForceAction = "Forcer action : %s, %s, %s"
EndTheBattle = "Terminer le combat"
# Warp
Warp = "Téléporter l'équipe :"
PlaceVehicle = "Placer véhicule :"
PlaceEvent = "Placer événement : %s, %s"
SwapPositions = "échanger la position avec [%s]"
Position = ["(X: %03d, Y: %03d)", "X: [%04d], Y: [%04d]", "échanger la position avec %s"]
# Deplacement
IsLooking = "Regarde vers"
Direction = {0 => "", 2 => ", le Bas", 4 => ", la Gauche", 6 => ", la Droite", 8 => ", le Haut"}
# Input
Inputs = { 2 =>"Bas", 4 => "Gauche", 6 => "Droite", 8 => "Haut", 11 => "A", 12 => "B", 13 => "C", 14 => "X",
15 => "Y", 16 => "Z", 17 => "L", 18 => "R" }
# Move route
MoveEvent = "Déplacer évènement :"
MoveRouteParams = ["Répéter", "Ignorer action impossible", "Attendre la fin"]
MoveRouteCommands = ["", "Un pas vers le Bas", "Un pas vers la Gauche", "Un pas vers la Droite",
"Un pas vers le Haut", "Un pas vers Bas-Gauche", "Un pas vers Bas-Droite", "Un pas vers Haut-Gauche",
"Un pas vers Haut-Droite", "Un pas au Hasard", "Un pas vers le Héros", "Fuis le héros d'un pas",
"Un pas en Avant", "Un pas en Arrière", "Saut : %s en X, %s en Y", "Attendre : %d Frames",
"Regarde vers le Bas", "Regarde vers la Gauche", "Regarde vers la Droite", "Regarde vers le Haut",
"Quart de tour à Droite", "Quart de tour à Gauche", "Demi tour", "Quart de tour au Hasard",
"Regarde Direction Aléat.", "Regarde vers le héros", "Se détourne du héros", "Active Inter. : %04d",
"Désactive Inter. : %04d", "Modifier Vitesse. : %d", "Modifier Fréquence : %d", "Marche animée ON",
"Marche animée OFF", "Animé à l'arrêt ON", "Animé à l'arrêt OFF", "Direction fixe ON", "Direction fixe OFF",
"Passe-muraille ON", "Passe-muraille OFF", "Transparent ON", "Transparent OFF", "Modifier charset : %s",
"Modifier opacité : %d", "Modifier transp. : %s", "Jouer un SE : %s",
"Appeller Script : %s"]
# Visual
Caterpillar = "Chenille :"
RegroupCaterpillar = "Regrouper la chenille"
Transparency = ["Normale", "Éclaircie", "Obscurcie"]
ScrollMap = "Faire défiler la carte vers"
ScrollMapParams = "de %d carreaux, vitesse %d"
EnterExitVehicle = "Entrer/Sortir du véhicule"
Opacity = ["Transparent", "Opaque"]
SetOpacity = "Transparence du héros :"
DisplayAnimation = "Afficher une animation : Cible - %s,"
DisplayEmote = "Afficher une émoticône : Cible - %s,"
DeleteEvent = "Effacer cet événement"
Emotes = ["Exclamation", "Interrogation", "Note de Musique", "Coeur", "Colère",
"Goute", "Toile", "Silence", "Ampoule", "Zzz"]
# Appearance
None = "(aucun)"
# Visual Effects
Color = ["(R:%d,V:%d,B:%d,I:%d)", "(R:%d,V:%d,B:%d)"]
Tone = "(R:%d,V:%d,B:%d,G:%d)"
FadeIn = "Effacer l'écran en fondu"
FadeOut = "Afficher l'écran en fondu"
ScreenTone = "Ton de l'écran : %s, %d Frames%s"
FlashScreen = "Flasher l'écran : %s, %d Frames%s"
ShakeScreen = "Secouer l'écran : Force %d, Vitesse %d, %d Frames%s"
# Pictures
DisplayPicture = "Afficher une image : %d, '%s', %s %s, (%d%%,%d%%), %d, %s"
MovePicture = "Afficher une image : %d, '%s', %s %s, (%d%%,%d%%), %d, %s, %d Frames%s"
PositionPicture = [["H.G.", "Ctre"], ["(%d,%d)", "(X:[%04d], Y:[%04d])"]]
RotatePicture = "Rotation Image : %d, Vitesse %s%d"
TonePicture = "Ton Image : %d, %s, %d Frames%s"
DeletePicture = "Effacer Image : %d"
WeatherEffect = "Effet Météorologique : %s, %d Frames%s"
Weather = {none: "Aucun", rain: "Pluie, %d", storm: "Orage, %d", snow: "Neige, %d"}
# Graphics
DisplayMapName = "Affichage du nom de la carte :"
ChangeTileset = "Changer de tileset :"
ChangeBattleBack = ["Changer le fond de combat : %s", "Changer le fond de combat : %s & %s"]
ChangePanorama = "Changer de panorama : '%s'"
GetInformation = "Récupérer des informations : [%04d], %s,"
GetInformationCoord = ["(%03d,%03d)", "Variable [%04d][%04d]"]
#--------------------------------------------------------------------------
# Window Vocab
#--------------------------------------------------------------------------
module Windows
# Helper text for scene
Helper = ["Choisissez la map", "Choisissez le type", "Choisissez l'évènement", "Choisissez la page",
"Choisissez l'action à effectuer"]
# WindowType content
Types = {map: "Events", common: "Events commun", battle: "Events de combat"}
# WindowMode content
Modes = {print_raw: "En brut - Dans un fichier", copy_raw: "En brut - Dans le presse-papier",
print_bbcode: "En BBcode - Dans un fichier", copy_bbcode: "En BBcode - Dans le presse-papier",
print_html: "En HTML - Dans un fichier", copy_html: "En HTML - Dans le presse-papier"}
# Page Name for WindowPage
PageName = "Page n°%03d"
# Event Name for WindowEvent
EventName = "[%03d]%s"
end
end
# End of Vocab ------------------------------------------------------------------------------------------------
module Utilities
extend self
#--------------------------------------------------------------------------
# * Get switch name
#--------------------------------------------------------------------------
def switch_name(id)
return name(sprintf("%04d", id)) if $data_system.switches[id] == ""
name(sprintf(Vocab::VariableName, id, $data_system.switches[id]))
end
#--------------------------------------------------------------------------
# * Get variable name
#--------------------------------------------------------------------------
def variable_name(id)
return name(sprintf("%04d", id)) if $data_system.variables[id] == ""
name(sprintf(Vocab::VariableName, id, $data_system.variables[id]))
end
#--------------------------------------------------------------------------
# * Get the variable name
#--------------------------------------------------------------------------
def la_variable(id)
Vocab::Variable + " " + variable_name(id)
end
#--------------------------------------------------------------------------
# * Get group name
def group_name(id1, id2)
name(sprintf(Vocab::Group, id1, id2))
end
#--------------------------------------------------------------------------
# * Get group or uniq variable
#--------------------------------------------------------------------------
def group_or_uniq(id1, id2, switch = true)
if id1 == id2
switch ? switch_name(id1) : variable_name(id1)
else
group_name(id1, id2)
end
end
#--------------------------------------------------------------------------
# * Get Event Name
#--------------------------------------------------------------------------
def event_name(id, map)
case id
when -1; Vocab::HeroEvent
when 0; Vocab::ThisEvent
else; sprintf(Vocab::Name, map.events[id].name)
end
end
#--------------------------------------------------------------------------
# * Get the map name
#--------------------------------------------------------------------------
def map_name(id)
(load_data("Data/MapInfos.rvdata2").find { |map| map[1].parent_id = id })[1].name
end
#--------------------------------------------------------------------------
# * Get hero name
#--------------------------------------------------------------------------
def tileset_name(id)
$data_tilesets[id].name
end
#--------------------------------------------------------------------------
# * Get hero name
#--------------------------------------------------------------------------
def hero_name(id)
id == 0 ? Vocab::WholeTeam : name($data_actors[id].name)
end
#--------------------------------------------------------------------------
# * Get class name
#--------------------------------------------------------------------------
def class_name(id)
name($data_classes[id].name)
end
#--------------------------------------------------------------------------
# * Get a foe name (in battle)
def foe_name(id, event)
return Vocab::AllEnemies if id == -1
sprintf(Vocab::Enemy, id + 1, event.troop.empty? ? "" : enemy_name(event.troop[id].enemy_id, false))
end
#--------------------------------------------------------------------------
# * Get a certain type of item name
# **(type : 0 => Item, 1 => Weapon, 2 => Armor)
#--------------------------------------------------------------------------
def base_item_name(type, id)
type == 0 ? item_name(id) : equipement_name(type-1, id)
end
#--------------------------------------------------------------------------
# * Get item name
#--------------------------------------------------------------------------
def item_name(id)
name($data_items[id].name)
end
#--------------------------------------------------------------------------
# * Get skill name
#--------------------------------------------------------------------------
def skill_name(id)
name($data_skills[id].name)
end
#--------------------------------------------------------------------------
# * Get an certain type of equipement name
#--------------------------------------------------------------------------
def equipement_name(type, id)
return Vocab::None if id == 0
type == 0 ? weapon_name(id) : armor_name(id)
end
#--------------------------------------------------------------------------
# * Get weapon name
#--------------------------------------------------------------------------
def weapon_name(id)
name($data_weapons[id].name)
end
#--------------------------------------------------------------------------
# * Get armor name
#--------------------------------------------------------------------------
def armor_name(id)
name($data_armors[id].name)
end
#--------------------------------------------------------------------------
# * Get state name
#--------------------------------------------------------------------------
def state_name(id)
name($data_states[id].name)
end
#--------------------------------------------------------------------------
# * Get common event name
#--------------------------------------------------------------------------
def common_event_name(id)
name($data_common_events[id].name)
end
#--------------------------------------------------------------------------
# * Get animation name
#--------------------------------------------------------------------------
def animation_name(id)
name($data_animations[id].name)
end
#--------------------------------------------------------------------------
# * Get enemy name
#--------------------------------------------------------------------------
def enemy_name(id, with_brackets = true)
with_brackets ? name($data_enemies[id].name) : $data_enemies[id].name
end
#--------------------------------------------------------------------------
# * Put the string between [ and ]
#--------------------------------------------------------------------------
def name(string)
sprintf(Vocab::Name, string)
end
#--------------------------------------------------------------------------
# * Get a target's name
#--------------------------------------------------------------------------
def target_name(id)
case id
when -2; Vocab::LastTarget
when -1; Vocab::RandomTarget;
else; sprintf(Vocab::Target, id+1); end
end
end
# End of Utilitities ------------------------------------------------------------------------------------------------
#==============================================================================
# ** EventCommand
#------------------------------------------------------------------------------
# Handle the conversion form code, indent and parameters to a representation
#==============================================================================
class EventCommand
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :event
#--------------------------------------------------------------------------
# * Hash which convert event command to a array representation
# ** Lambdas => should return a array like :
# [ true|false (Put the > or not)
# {color: :some_color_symbol, text: "Some text" }
# {color: :some_other_color_symbol, text: "Some other text" } ]
#--------------------------------------------------------------------------
CommandHash = {
0 => ->(params, event){ [true] },
101 => ->(params, event){ [true,
{color: :standard, text: EventPrinter::Vocab::Message},
{color: :parameters, text: sprintf(EventPrinter::Vocab::MessageParams,
params[0].empty? ? EventPrinter::Vocab::Void : "'#{params[0]}'", params[0].empty? ?
EventPrinter::Vocab::Void : params[1].to_s, EventPrinter::Vocab::MessageDisplay[params[2]],
EventPrinter::Vocab::MessagePosition[params[3]])}
]},
102 => ->(params, event){ [true,
{color: :standard, text: EventPrinter::Vocab::Choices},
{color: :text, text: params[0].join(", ")}] },
103 => ->(params, event){ [true,
{color: :standard, text: sprintf(EventPrinter::Vocab::GetVar,
EventPrinter::Utilities::variable_name(params[0]), params[1])}] },
104 => ->(params, event){ [true,
{color: :standard, text: sprintf(EventPrinter::Vocab::SelectItem,
EventPrinter::Utilities::variable_name(params[0]))}] },
105 => ->(params, event){ [true,
{color: :standard, text: EventPrinter::Vocab::DisplayScrollingText},
{color: :parameters, text: sprintf(EventPrinter::Vocab::ScrollSpeed, params[0])},
{color: :parameters, text: (params[1] ? EventPrinter::Vocab::DisableFastForward : "")}] },
108 => ->(params, event){ [true,
{color: :comments, text: EventPrinter::Vocab::Comment},
{color: :comments, text: params[0]}] },
111 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::Condition},
{color: :function, text: ConditionArray[params[0]].call(params[1..-1], event) }]},
112 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::Loop}]},
113 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::ExitLoop}]},
115 => lambda { |params, event| [true,
{:color => :function, :text => EventPrinter::Vocab::StopEvents}]},
117 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::CommonEventCall},
{color: :function, text: EventPrinter::Utilities::common_event_name(params[0])}
]},
118 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::Goto},
{color: :function, text: params[0]}
]},
119 => ->(params, event){ [true,
{color: :function, text: EventPrinter::Vocab::GotoCall},
{color: :function, text: params[0]}
]},
121 => ->(params, event){ [true,
{color: :variables, text: EventPrinter::Vocab::Operation},
{color: :variables, text: EventPrinter::Vocab::Switch},
{color: :variables, text: EventPrinter::Utilities::group_or_uniq(params[0], params[1], true)},
{color: :variables, text: EventPrinter::Vocab::OnOff[params[2]]}] },
122 => ->(params, event){ [true,
{color: :variables, text: EventPrinter::Vocab::Operation},
{color: :variables, text: EventPrinter::Vocab::Variable},
{color: :variables, text: EventPrinter::Utilities::group_or_uniq(params[0], params[1], false)},
{color: :variables, text: EventPrinter::Vocab::Operators[params[2]]},
{color: :variables, text: OperandArray[params[3]].call(params[4..-1], event)} ]},
123 => ->(params, event){ [true,
{color: :variables, text: EventPrinter::Vocab::Operation},
{color: :variables, text: EventPrinter::Vocab::LocalSwitch},
{color: :variables, text: params[0]},
{color: :variables, text: EventPrinter::Vocab::Operators[0]},
{color: :variables, text: EventPrinter::Vocab::OnOff[params[1]]}]},
124 => ->(params, event){ [true,
{color: :variables, text: EventPrinter::Vocab::Chronometer},
{color: :variables, text: params[0] == 0 ? sprintf(EventPrinter::Vocab::Start,
params[1] / 60, params[1] % 60) : EventPrinter::Vocab::Stop
}] },
125 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyMoney},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[0]]},
{color: :manage, text: params[1] == 0 ? params[2].to_s : EventPrinter::Utilities::la_variable(params[2])}
] },
126 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyItem},
{color: :manage, text: EventPrinter::Utilities::item_name(params[0])},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :manage, text: params[2] == 0 ? params[3].to_s : EventPrinter::Utilities::la_variable(params[3])}
] },
127 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyWeapon},
{color: :manage, text: EventPrinter::Utilities::weapon_name(params[0])},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :manage, text: sprintf(
params[1] == 1 && params[4] ? EventPrinter::Vocab::ModifyTextWithIncluded : "%s",
params[2] == 0 ? params[3].to_s : EventPrinter::Utilities::la_variable(params[3]))}
] },
128 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyArmor},
{color: :manage, text: EventPrinter::Utilities::armor_name(params[0])},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :manage, text: sprintf(
params[1] == 1 && params[4] ? EventPrinter::Vocab::ModifyTextWithIncluded : "%s",
params[2] == 0 ? params[3].to_s : EventPrinter::Utilities::la_variable(params[3]))}
] },
129 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyParty},
{color: :manage, text: EventPrinter::Vocab::AddOrRemove[params[1]]},
{color: :manage, text: sprintf(
params[1] == 0 && params[2] == 1 ? EventPrinter::Vocab::ModifyPartyTextWithReset : "%s",
EventPrinter::Utilities::hero_name(params[0]))}
] },
132 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifyBGM},
{color: :system, text: params[0].to_string_params}
] },
133 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifyME},
{color: :system, text: params[0].to_string_params}
] },
134 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifiySave},
{color: :system, text: EventPrinter::Vocab::SwitchOnOff[params[0]]}
] },
135 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifiyMenu},
{color: :system, text: EventPrinter::Vocab::SwitchOnOff[params[0]]}
] },
136 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifiyEncounter},
{color: :system, text: EventPrinter::Vocab::SwitchOnOff[params[0]]}
] },
137 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ModifiyFormation},
{color: :system, text: EventPrinter::Vocab::SwitchOnOff[params[0]]}
] },
138 => ->(params, event){ [true,
{color: :system, text: sprintf(EventPrinter::Vocab::WindowColor, params[0].to_string_params)}
] },
201 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::Warp},
{color: :events, text: WarpText[params[0]].call(params[1..-1]) +
EventPrinter::Vocab::Direction[params[4]] }
] },
202 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::PlaceVehicle},
{color: :events, text: EventPrinter::Vocab::Vehicle[params[0]]},
{color: :events, text: WarpText[params[1]].call(params[2..-1])}
] },
203 => ->(params, event){ [true,
{color: :events, text: (sprintf(EventPrinter::Vocab::PlaceEvent,
EventPrinter::Utilities::event_name(params[0], event.map), PositionArray[params[1]].call(params[2..-1], event)
) + EventPrinter::Vocab::Direction[params[4]])}
]},
204 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::ScrollMap},
{color: :events, text: EventPrinter::Vocab::Direction[params[0]]},
{color: :events, text: sprintf(EventPrinter::Vocab::ScrollMapParams, *params[1..-1])} ]},
205 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::MoveEvent},
{color: :events, text: EventPrinter::Utilities::event_name(params[0], event.map)},
{color: :events, text: params[1].to_string_params } ]},
206 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::EnterExitVehicle}
]},
211 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::SetOpacity},
{color: :events, text: EventPrinter::Vocab::Opacity[params[0]]}
]},
212 => ->(params, event){ [true,
{color: :events, text: sprintf(EventPrinter::Vocab::DisplayAnimation,
EventPrinter::Utilities::event_name(params[0], event.map))},
{color: :events, text: EventPrinter::Utilities::animation_name(params[1])}
]},
213 => ->(params, event){ [true,
{color: :events, text: sprintf(EventPrinter::Vocab::DisplayEmote,
EventPrinter::Utilities::event_name(params[0], event.map))},
{color: :events, text: EventPrinter::Vocab::Emotes[params[1]-1]}
]},
214 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::DeleteEvent}
]},
216 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::Caterpillar},
{color: :events, text: EventPrinter::Vocab::OnOff[params[0]]}
]},
217 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::RegroupCaterpillar}
]},
221 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::FadeIn}
]},
222 => ->(params, event){ [true,
{color: :events, text: EventPrinter::Vocab::FadeOut}
]},
223 => ->(params, event){ [true,
{color: :events, text: sprintf(EventPrinter::Vocab::ScreenTone, params[0].to_string_params, params[1],
params[2] ? EventPrinter::Vocab::WaitEnd : "")}
]},
224 => ->(params, event){ [true,
{color: :events, text: sprintf(EventPrinter::Vocab::FlashScreen, params[0].to_string_params, params[1],
params[2] ? EventPrinter::Vocab::WaitEnd : "")}
]},
225 => ->(params, event){ [true,
{color: :events, text: sprintf(EventPrinter::Vocab::ShakeScreen, params[0], params[1],
params[2], params[3] ? EventPrinter::Vocab::WaitEnd : "")}
]},
230 => ->(params, event){ [true,
{color: :wait, text: sprintf(EventPrinter::Vocab::Wait, params[0])}
]},
231 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::DisplayPicture, params[0], params[1],
EventPrinter::Vocab::PositionPicture[0][params[2]], sprintf(EventPrinter::Vocab::PositionPicture[1][params[3]],
params[4], params[5]), params[6], params[7], params[8], EventPrinter::Vocab::Transparency[params[9]])}
]},
232 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::MovePicture, params[0], params[1],
EventPrinter::Vocab::PositionPicture[0][params[2]], sprintf(EventPrinter::Vocab::PositionPicture[1][params[3]],
params[4], params[5]), params[6], params[7], params[8], EventPrinter::Vocab::Transparency[params[9]],
params[10], params[11] ? EventPrinter::Vocab::WaitEnd : "")}
]},
233 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::RotatePicture, params[0], params[1] > 0 ? "+" : "",
params[1])}
]},
234 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::TonePicture, params[0], params[1].to_string_params,
params[2], params[3] ? EventPrinter::Vocab::WaitEnd : "")}
]},
235 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::DeletePicture, params[0])}
]},
236 => ->(params, event){ [true,
{color: :pictures, text: sprintf(EventPrinter::Vocab::WeatherEffect,
sprintf(EventPrinter::Vocab::Weather[params[0]], params[1]), params[2],
params[3] ? EventPrinter::Vocab::WaitEnd : "")}
]},
241 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::BGM },
{color: :musics, text: params[0].to_string_params },
]},
242 => ->(params, event){ [true,
{color: :musics, text: sprintf(EventPrinter::Vocab::StopBGM, params[0]) }
]},
243 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::MemorizeBGM }
]},
244 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::RestartBGM }
]},
245 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::BGS },
{color: :musics, text: params[0].to_string_params },
]},
246 => ->(params, event){ [true,
{color: :musics, text: sprintf(EventPrinter::Vocab::StopBGS, params[0]) }
]},
249 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::ME },
{color: :musics, text: params[0].to_string_params },
]},
250 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::SE },
{color: :musics, text: params[0].to_string_params },
]},
251 => ->(params, event){ [true,
{color: :musics, text: EventPrinter::Vocab::StopSE }
]},
261 => ->(params, event){ [true,
{color: :musics, text: sprintf(EventPrinter::Vocab::PlayVideo, params[0]) }
]},
281 => ->(params, event){ [true,
{color: :graphics, text: EventPrinter::Vocab::DisplayMapName },
{color: :graphics, text: EventPrinter::Vocab::OnOff[params[0]]}
]},
282 => ->(params, event){ [true,
{color: :graphics, text: EventPrinter::Vocab::ChangeTileset },
{color: :graphics, text: EventPrinter::Utilities::tileset_name(params[0]) }
]},
283 => ->(params, event){ [true,
{color: :graphics, text: sprintf(EventPrinter::Vocab::ChangeBattleBack[params[1].empty? ? 0 : 1], *params)}
]},
284 => ->(params, event){ [true,
{color: :graphics, text: sprintf(EventPrinter::Vocab::ChangePanorama, *params)}
]},
285 => ->(params, event){ [true,
{color: :graphics, text: sprintf(EventPrinter::Vocab::GetInformation, *params)},
{color: :graphics, text: sprintf(EventPrinter::Vocab::GetInformationCoord[params[2]], *params[3..4])}
]},
301 => ->(params, event){ [true,
{color: :game, text: sprintf(EventPrinter::Vocab::Battle, params[0] == 0 ?
EventPrinter::Utilities::enemy_name(params[1]) : sprintf(EventPrinter::Vocab::BattleIndexed, params[1]))}
] },
302 => ->(params, event){ [true,
{color: :game, text: EventPrinter::Vocab::Shop},
{color: :game, text: EventPrinter::Utilities::base_item_name(*params[0..1])}
] },
303 => ->(params, event){ [true,
{color: :game, text: sprintf(EventPrinter::Vocab::EnterName,
EventPrinter::Utilities::hero_name(params[0])[1...-1], params[1])}
] },
311 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyHP},
{color: :manage, text: params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" ")},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[2]]},
{color: :manage, text: params[3] == 0 ? params[4].to_s : EventPrinter::Utilities::la_variable(params[4])}
] },
312 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::ModifyMP},
{color: :manage, text: params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" ")},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[2]]},
{color: :manage, text: params[3] == 0 ? params[4].to_s : EventPrinter::Utilities::la_variable(params[4])}
] },
313 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyStatus,
EventPrinter::Utilities::hero_name(params[0]))},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :manage, text: sprintf(EventPrinter::Vocab::Name, EventPrinter::Utilities::state_name(params[2]))}
] },
314 => ->(params, event){ [true,
{color: :manage, text: EventPrinter::Vocab::Recover},
{color: :manage, text: params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" ")}
] },
315 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyExperience,
params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" "))},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[2]]},
{color: :manage, text: params[3] == 0 ? params[4].to_s : EventPrinter::Utilities::la_variable(params[4])}
] },
316 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyLevel,
params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" "))},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[2]]},
{color: :manage, text: params[3] == 0 ? params[4].to_s : EventPrinter::Utilities::la_variable(params[4])}
] },
317 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyParameters,
params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" "))},
{color: :manage, text: EventPrinter::Vocab::Attributes[params[2] - 5]},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[3]]},
{color: :manage, text: params[4] == 0 ? params[5].to_s : EventPrinter::Utilities::la_variable(params[5])}
] },
318 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifySkill,
params[0] == 0 ? EventPrinter::Utilities::hero_name(params[1]) :
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[1])].join(" "))},
{color: :manage, text: EventPrinter::Vocab::PlusOrMinus[params[2]]},
{color: :manage, text: EventPrinter::Utilities::skill_name(params[3])}
] },
319 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyEquipement,
EventPrinter::Utilities::hero_name(params[0]))},
{color: :manage, text: EventPrinter::Vocab::Equipement[params[1]]},
{color: :manage, text: EventPrinter::Vocab::Operators[0]},
{color: :manage, text: EventPrinter::Utilities::equipement_name(params[1], params[2])}
] },
320 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyHeroName,
EventPrinter::Utilities::hero_name(params[0]))},
{color: :manage, text: "'#{params[1]}'"}
] },
321 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyHeroClass,
EventPrinter::Utilities::hero_name(params[0]))},
{color: :manage, text: EventPrinter::Utilities::class_name(params[1])}
] },
322 => ->(params, event){ [true,
{color: :system, text: sprintf(EventPrinter::Vocab::ModifyHeroAppearance,
EventPrinter::Utilities::hero_name(params[0]), *params[1..-1])}
] },
323 => ->(params, event){ [true,
{color: :system, text: sprintf(EventPrinter::Vocab::ModifyVehicleAppearance,
EventPrinter::Vocab::Vehicle[params[0]], *params[1..-1])},
] },
324 => ->(params, event){ [true,
{color: :manage, text: sprintf(EventPrinter::Vocab::ModifyHeroAlias,
EventPrinter::Utilities::hero_name(params[0]))},
{color: :manage, text: "'#{params[1]}'"}
] },
331 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::ModifyHPEnemy,
EventPrinter::Utilities::foe_name(params[0], event))},
{color: :battle, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :battle, text: params[2] == 0 ? params[3].to_s : EventPrinter::Utilities::la_variable(params[3])}
] },
332 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::ModifyMPEnemy,
EventPrinter::Utilities::foe_name(params[0], event))},
{color: :battle, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :battle, text: params[2] == 0 ? params[3].to_s : EventPrinter::Utilities::la_variable(params[3])}
] },
333 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::ModifyStatusEnemy,
EventPrinter::Utilities::foe_name(params[0], event))},
{color: :battle, text: EventPrinter::Vocab::PlusOrMinus[params[1]]},
{color: :battle, text: EventPrinter::Utilities::state_name(params[2])}
] },
334 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::RecoverEnemy,
EventPrinter::Utilities::foe_name(params[0], event))}
] },
335 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::RevealEnemy,
EventPrinter::Utilities::foe_name(params[0], event))}
] },
336 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::MorphEnemy,
EventPrinter::Utilities::foe_name(params[0], event), EventPrinter::Utilities::enemy_name(params[1]))}
] },
337 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::DisplayBattleAnimation,
EventPrinter::Utilities::foe_name(params[0], event))},
{color: :battle, text: EventPrinter::Utilities::animation_name(params[1])}
] },
339 => ->(params, event){ [true,
{color: :battle, text: sprintf(EventPrinter::Vocab::ForceAction, params[0] == 0 ?
EventPrinter::Utilities::foe_name(params[1], event) : sprintf(EventPrinter::Vocab::Battler, params[1] + 1),
EventPrinter::Utilities::skill_name(params[2]), EventPrinter::Utilities::target_name(params[3]))}
]},
340 => ->(params, event){ [true,
{color: :battle, text: EventPrinter::Vocab::EndTheBattle}]},
351 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::OpenMenu}]},
352 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::OpenSave}]},
353 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::GameOver}]},
354 => ->(params, event){ [true,
{color: :system, text: EventPrinter::Vocab::ToTitle}]},
355 => ->(params, event){ [true,
{color: :script, text: EventPrinter::Vocab::ScriptCall},
{color: :script, text: params[0]}
] },
401 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::Message[0...-2]}, # Without the ":" and space
{color: :standard, text: ":"},
{color: :text, text: params[0]}] },
402 => ->(params, event){ [false,
{color: :standard, text: sprintf(EventPrinter::Vocab::Choice, "[#{params[1]}]")}] },
403 => ->(params, event){ [false,
{color: :standard, text: sprintf(EventPrinter::Vocab::Choice, EventPrinter::Vocab::CancelChoice)}] },
404 => ->(params, event){ [false,
{color: :standard, text: EventPrinter::Vocab::EndChoice}] },
405 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::DisplayScrollingText[0...-2]},
{color: :standard, text: ":"},
{color: :text, text: params[0]}] },
408 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::Comment[0...-2]},
{color: :events, text: ":"},
{color: :comments, text: params[0]}] },
411 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::Else}] },
412 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::EndCondition}] },
413 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::EndLoop}] },
505 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::MoveEvent[0...-2]},
{color: :events, text: ":"},
{color: :events, text: EventPrinter::Vocab::Command[2]},
{color: :events, text: sprintf(EventPrinter::Vocab::MoveRouteCommands[params[0].code],
*params[0].to_params)}
]},
601 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::IfVictory}] },
602 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::IfFlee}] },
603 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::IfLoss}] },
604 => ->(params, event){ [false,
{color: :function, text: EventPrinter::Vocab::EndBattle}] },
605 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::Shop[0...-2]},
{color: :game, text: ":"},
{color: :game, text: EventPrinter::Utilities::base_item_name(*params[0..1])}
] },
655 => ->(params, event){ [false,
{color: :nothing, text: EventPrinter::Vocab::ScriptCall[0...-2]},
{color: :script, text: ":"},
{color: :script, text: params[0]}
] },
}
#--------------------------------------------------------------------------
# * Converts params for variable operation
#--------------------------------------------------------------------------
OperandArray = [
->(params, event){params[0].to_s},
->(params, event){
sprintf(EventPrinter::Vocab::ValueOfVariable, EventPrinter::Utilities::variable_name(params[0]))},
->(params, event){
sprintf(EventPrinter::Vocab::RandomValue, params[0], params[1]) },
->(params, event){[
->(params, event){sprintf(EventPrinter::Vocab::NumberOf, EventPrinter::Utilities::item_name(params[0]))},
->(params, event){sprintf(EventPrinter::Vocab::NumberOf, EventPrinter::Utilities::weapon_name(params[0]))},
->(params, event){sprintf(EventPrinter::Vocab::NumberOf, EventPrinter::Utilities::armor_name(params[0]))},
->(params, event){sprintf("%s : %s", EventPrinter::Utilities::hero_name(params[0]),
EventPrinter::Vocab::Attributes[params[1]])},
->(params, event){sprintf("%s : %s", EventPrinter::Utilities::foe_name(params[0], event),
EventPrinter::Vocab::Attributes[params[1]+2]) },
->(params, event){sprintf("%s : %s", EventPrinter::Utilities::event_name(params[0], event.map),
EventPrinter::Vocab::EventParam[params[1]]) },
->(params, event){sprintf(EventPrinter::Vocab::IdOfAMember, EventPrinter::Vocab::OrdinalNumber[params[0]])},
->(params, event){EventPrinter::Vocab::OtherVariable[params[0]] }
][params[0]].call(params[1..-1], event) },
->(params, event) {params[0]}
]
#--------------------------------------------------------------------------
# * Converts params for conditions
#--------------------------------------------------------------------------
ConditionArray = [
->(params, event){
[EventPrinter::Vocab::Switch, EventPrinter::Utilities::switch_name(params[0]),
EventPrinter::Vocab::ComparationOperator[0],
EventPrinter::Vocab::OnOff[params[1]]].join(" ")
},
->(params, event){
[EventPrinter::Vocab::Variable, EventPrinter::Utilities::variable_name(params[0]),
EventPrinter::Vocab::ComparationOperator[params[3]],
params[1] == 0 ? params[2].to_s : sprintf("%s %s", EventPrinter::Vocab::Variable,
EventPrinter::Utilities::variable_name(params[2]))
].join(" ")
},
->(params, event){
[EventPrinter::Vocab::LocalSwitch, params[0],
EventPrinter::Vocab::ComparationOperator[0],
EventPrinter::Vocab::OnOff[params[1]]].join(" ")
},
->(params, event){
[EventPrinter::Vocab::LeChronometer,
sprintf(EventPrinter::Vocab::Start, params[0] / 60, params[0] % 60) ,
EventPrinter::Vocab::MoreOrLess[params[1]] ].join(" ")
},
->(params, event){
[EventPrinter::Utilities::hero_name(params[0]),
sprintf(EventPrinter::Vocab::HeroConditions[params[1]], HeroConditionString[params[1]].call(params[2]))
].join(" ")
},
->(params, event){ [EventPrinter::Utilities::foe_name(params[0], event),
params[1] == 0 ? EventPrinter::Vocab::Present :
sprintf(EventPrinter::Vocab::HeroConditions[5], EventPrinter::Utilities::state_name(params[2]))
].join(" ")
},
->(params, event){
[EventPrinter::Utilities::event_name(params[0], event.map), EventPrinter::Vocab::IsLooking,
EventPrinter::Vocab::Direction[params[1]]].join(" ")
},
->(params, event){
sprintf(EventPrinter::Vocab::MoneyCondition, params[0], EventPrinter::Vocab::MoreOrLess[params[1]])
},
->(params, event){
sprintf(EventPrinter::Vocab::ItemCondition, EventPrinter::Utilities::item_name(params[0]))
},
->(params, event){
sprintf(EventPrinter::Vocab::WeaponCondition, EventPrinter::Utilities::weapon_name(params[0]),
params[1] ? EventPrinter::Vocab::OrEquipped : "")
},
->(params, event){
sprintf(EventPrinter::Vocab::ArmorCondition, EventPrinter::Utilities::armor_name(params[0]),
params[1] ? EventPrinter::Vocab::OrEquipped : "")
},
->(params, event){
sprintf(EventPrinter::Vocab::KeyCondition, EventPrinter::Vocab::Inputs[params[0]])
},
->(params, event){
sprintf(EventPrinter::Vocab::ScriptCondition, params[0])
},
->(params, event){
sprintf(EventPrinter::Vocab::VehicleCondition, EventPrinter::Vocab::Vehicle[params[0]])
}
]
#--------------------------------------------------------------------------
# * Converts params for hero conditions
#--------------------------------------------------------------------------
HeroConditionString = [ ->(params){""},
->(params){ params.to_s },
->(params){ EventPrinter::Utilities::skill_name(params)},
->(params){ EventPrinter::Utilities::class_name(params)},
->(params){ EventPrinter::Utilities::weapon_name(params)},
->(params){ EventPrinter::Utilities::armor_name(params)},
->(params){ EventPrinter::Utilities::state_name(params)}
]
#--------------------------------------------------------------------------
# * Converts params for warp
#--------------------------------------------------------------------------
WarpText = [
->(params){ sprintf("[%03d:%s], (X:%03d, Y:%03d)", params[0],
EventPrinter::Utilities::map_name(params[0]), params[1], params[2]) },
->(params){ sprintf("ID:[%04d], X:[%04d], Y:[%04d]", *params) }
]
#--------------------------------------------------------------------------
# * Converts params for variable operation
#--------------------------------------------------------------------------
PositionArray = [
->(params, event){ sprintf(EventPrinter::Vocab::Position[0], *params)},
->(params, event){ sprintf(EventPrinter::Vocab::Position[1], *params)},
->(params, event){ sprintf(EventPrinter::Vocab::Position[2],
EventPrinter::Utilities::event_name(params[0], event.map))}
]
#--------------------------------------------------------------------------
# * Initialization
#--------------------------------------------------------------------------
def initialize(code = 0, indent = 0, parameters = [], event = nil)
@code = code
@indent = indent
@parameters = parameters
@event = event
@parse_results = parse
minimize
end
#--------------------------------------------------------------------------
# * Add indent to representation
#--------------------------------------------------------------------------
def parse
{:indent => @indent, :command => parse_command}
end
#--------------------------------------------------------------------------
# * Parse command
#--------------------------------------------------------------------------
def parse_command
CommandHash[@code].call(@parameters, @event)
end
#--------------------------------------------------------------------------
# * From representation to raw
#--------------------------------------------------------------------------
def raw
text = (@parse_results[:command][1..-1].map {|a| a[:text]}).join(" ")
((EventPrinter::Vocab::Command + " ") * (@parse_results[:indent] + 1)) + text
end
#--------------------------------------------------------------------------
# * From representation to bbcode
#--------------------------------------------------------------------------
def bbcode
start = sprintf("%s%s%s",
EventPrinter::BBcode::colorize(:nothing, EventPrinter::Vocab::Command) * @parse_results[:indent],
EventPrinter::BBcode::colorize(:standard, EventPrinter::Vocab::Command[0..1]),
EventPrinter::BBcode::colorize(
@parse_results[:command].first ? :standard : :nothing, EventPrinter::Vocab::Command[2..2] << " "))
text = (@parse_results[:command][1..-1].map do |hash|
EventPrinter::BBcode::colorize(hash[:color], hash[:text])
end).join("")
EventPrinter::BBcode::line(start + text)
end
#--------------------------------------------------------------------------
# * From representation to html
#--------------------------------------------------------------------------
def html
start = sprintf("%s%s%s",
EventPrinter::HTML::colorize(:nothing, EventPrinter::Vocab::Command) * @parse_results[:indent],
EventPrinter::HTML::colorize(:standard, EventPrinter::Vocab::Command[0..1]),
EventPrinter::HTML::colorize(
@parse_results[:command].first ? :standard : :nothing, EventPrinter::Vocab::Command[2..2] << " "))
text = (@parse_results[:command][1..-1].map do |hash|
EventPrinter::HTML::colorize(hash[:color], hash[:text])
end).join("")
EventPrinter::HTML::line(start + text)
end
#--------------------------------------------------------------------------
# * Minimize representation (merge same color texts)
#--------------------------------------------------------------------------
def minimize
return unless @parse_results[:command][2]
tab = [{color: @parse_results[:command][1][:color], text: ""}]
@parse_results[:command][1..-1].each do |part|
tab << {color: part[:color], text: ""} if tab.last[:color] != part[:color]
tab.last[:text] << part[:text] << " "
end
@parse_results[:command][1..-1] = tab
end
end
# End of Command ------------------------------------------------------------------------------------------------
#==============================================================================
# ** EventPage
#------------------------------------------------------------------------------
# Handle access to an event's page.
#==============================================================================
class Page
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :list
#--------------------------------------------------------------------------
# * Initialization
# ** list list from a RPG::Event::Page list
# ** event EventPrinter::Event
#--------------------------------------------------------------------------
def initialize(list, event)
@list = list.collect do |command|
EventPrinter::EventCommand.new(command.code, command.indent, command.parameters, event)
end
@event = event
end
#--------------------------------------------------------------------------
# * Prints in a file raw conversion of commands
#--------------------------------------------------------------------------
def print_raw(filename = @event.printed_name)
confirm_filename(filename)
filename << "_raw.txt"
File.open(filename, "w+") do |file|
file.puts @event.printed_name
@list.map do |elt|
file.puts elt.raw
end
end
end
#--------------------------------------------------------------------------
# * Prints in a file BBcode conversion of commands
#--------------------------------------------------------------------------
def print_bbcode(filename = @event.printed_name)
confirm_filename(filename)
filename << "_bbcode.txt"
File.open(filename, "w+") do |file|
file.write EventPrinter::BBcode::head(@event.printed_name)
@list.map do |elt|
file.puts elt.bbcode
end
file.write EventPrinter::BBcode::foot
end
end
#--------------------------------------------------------------------------
# * Prints in a file HTML conversion of commands
#--------------------------------------------------------------------------
def print_html(filename = @event.printed_name)
confirm_filename(filename)
filename << "_html.txt"
File.open(filename, "w+") do |file|
file.write EventPrinter::HTML::head(@event.printed_name)
@list.map do |elt|
file.write elt.html
end
file.write EventPrinter::HTML::foot
end
end
#--------------------------------------------------------------------------
# * Copy the raw conversion of commands
#--------------------------------------------------------------------------
def copy_raw
Win32API.push_text_in_clipboard(((@list.map {|e| e.raw}).join("\n") + "\0").to_ascii)
end
#--------------------------------------------------------------------------
# * Copy the BBcode conversion of commands
#--------------------------------------------------------------------------
def copy_bbcode
str = EventPrinter::BBcode::head(@event.printed_name)
str << (@list.map { |e| e.bbcode }).join("\n")
str << EventPrinter::BBcode::foot
Win32API.push_text_in_clipboard(str.to_ascii << "\0")
end
#--------------------------------------------------------------------------
# * Copy the HTML conversion of commands
#--------------------------------------------------------------------------
def copy_html
str = EventPrinter::HTML::head(@event.printed_name)
str << (@list.map { |e| e.html }).join
str << EventPrinter::HTML::foot
Win32API.push_text_in_clipboard(str.to_ascii << "\0")
end
#--------------------------------------------------------------------------
# * Make an okay filename
#--------------------------------------------------------------------------
def confirm_filename(filename)
filename.gsub!(/[<>:"\/\\|?*]/) { "" }
end
end
# End of Page ------------------------------------------------------------------------------------------------
#==============================================================================
# ** Event
#------------------------------------------------------------------------------
# Handle access to an event
#==============================================================================
class Event
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :map
attr_reader :pages
attr_reader :troop
#--------------------------------------------------------------------------
# * Initialization
# ** event EventPrinter::Event
# ** map RPG::Map
#--------------------------------------------------------------------------
def initialize(event, map)
@id = event.id
@name = event.name
@event = event
@map = map
@troop ||= []
@pages ||= @event.pages.collect do |page|
EventPrinter::Page.new(page.list, self)
end
end
#--------------------------------------------------------------------------
# * Build an event from its id and its map id
#--------------------------------------------------------------------------
def self.build(id_event, id_map)
map = load_data(sprintf("Data/Map%03d.rvdata2", id_map))
event = map.events[id_event]
self.new(event, map)
end
#--------------------------------------------------------------------------
# * Prints in a file a page to raw format
#--------------------------------------------------------------------------
def print_raw(no_page = 0)
@pages[no_page].print_raw
end
#--------------------------------------------------------------------------
# * Prints in a file a page to BBcode format
#--------------------------------------------------------------------------
def print_bbcode(no_page = 0)
@pages[no_page].print_bbcode
end
#--------------------------------------------------------------------------
# * Prints in a file a page to HTML format
#--------------------------------------------------------------------------
def print_html(no_page = 0)
@pages[no_page].print_html
end
#--------------------------------------------------------------------------
# * Copy a page to raw format
#--------------------------------------------------------------------------
def copy_raw(no_page = 0)
@pages[no_page].copy_raw
end
#--------------------------------------------------------------------------
# * Copy a page to BBcode format
#--------------------------------------------------------------------------
def copy_bbcode(no_page = 0)
@pages[no_page].copy_bbcode
end
#--------------------------------------------------------------------------
# * Copy a page to HTML format
#--------------------------------------------------------------------------
def copy_html(no_page = 0)
@pages[no_page].copy_html
end
#--------------------------------------------------------------------------
# * String name
#--------------------------------------------------------------------------
def printed_name
"Event - #{@name}"
end
end
#==============================================================================
# ** CommonEvent
#------------------------------------------------------------------------------
# Handle access to a common event
#==============================================================================
class CommonEvent < Event
#--------------------------------------------------------------------------
# * Initialization
# ** event EventPrinter::Event
# ** map RPG::Map
#--------------------------------------------------------------------------
def initialize(event, map)
@map = map
@pages = [EventPrinter::Page.new(event.list, self)]
super
end
#--------------------------------------------------------------------------
# * Build an event from its id and its map id
#--------------------------------------------------------------------------
def self.build(id_event, id_map = 0)
map = load_data(sprintf("Data/Map%03d.rvdata2", id_map))
event = load_data("Data/CommonEvents.rvdata2")[id_event]
self.new(event, map)
end
#--------------------------------------------------------------------------
# * String name
#--------------------------------------------------------------------------
def printed_name
"CommonEvent - #{@name}"
end
end
#==============================================================================
# ** BattleEvent
#------------------------------------------------------------------------------
# Handle access to a battle event
#==============================================================================
class BattleEvent < Event
#--------------------------------------------------------------------------
# * Initialization
# ** event EventPrinter::Event
# ** map RPG::Map
#--------------------------------------------------------------------------
def initialize(event, map)
@troop = event.members
super
end
#--------------------------------------------------------------------------
# * Build an event from its id and its map id
#--------------------------------------------------------------------------
def self.build(id_event, id_map = 0)
map = load_data(sprintf("Data/Map%03d.rvdata2", id_map))
event = load_data("Data/Troops.rvdata2")[id_event]
self.new(event, map)
end
#--------------------------------------------------------------------------
# * String name
#--------------------------------------------------------------------------
def printed_name
"BattleEvent - #{@name}"
end
end
# End of Event ------------------------------------------------------------------------------------------------
#==============================================================================
# ** BBcode helper methods
#==============================================================================
module BBcode
#---------------------------------------------------------------------------------------------
# * Public module methods
#---------------------------------------------------------------------------------------------
extend self
#--------------------------------------------------------------------------
# ** Head
#--------------------------------------------------------------------------
def head(string_name = "foo")
sprintf("[table style='background-color:%s;border:1px solid; padding: 5px;text-shadow:none' class='event_code']%s",
EventPrinter::Theme::Nothing, name(string_name))
end
#--------------------------------------------------------------------------
# ** Name
#--------------------------------------------------------------------------
def name(string)
sprintf("[b]%s[/b]", string)
end
#--------------------------------------------------------------------------
# ** Colorization
#--------------------------------------------------------------------------
def colorize(color, string)
sprintf("[color=%s]%s[/color]", EventPrinter::Theme::get_color(color), string)
end
#--------------------------------------------------------------------------
# ** Line
#--------------------------------------------------------------------------
def line(string)
sprintf("[tr][td]%s[/td][/tr]", string)
end
#--------------------------------------------------------------------------
# ** Footer
#--------------------------------------------------------------------------
def foot
"[/table]"
end
end
#==============================================================================
# ** HTML helper methods
#==============================================================================
module HTML
#---------------------------------------------------------------------------------------------
# * Public module methods
#---------------------------------------------------------------------------------------------
extend self
#--------------------------------------------------------------------------
# ** Head
#--------------------------------------------------------------------------
def head(string_name = "foo")
sprintf("%s<div style='background-color:%s; border: #94a4be 1px solid; padding: 5px;text-shadow:none class='event_code'>",
name(string_name), EventPrinter::Theme::Nothing)
end
#--------------------------------------------------------------------------
# ** Name
#--------------------------------------------------------------------------
def name(string)
sprintf("<span style='font-weight: bold; padding: 0px'\>%s</span>", string)
end
#--------------------------------------------------------------------------
# ** Colorization
#--------------------------------------------------------------------------
def colorize(color, string)
sprintf("<span style='color:%s'>%s</span>", EventPrinter::Theme::get_color(color), string)
end
#--------------------------------------------------------------------------
# ** Line
#--------------------------------------------------------------------------
def line(string)
sprintf("<p style='margin: 0'>%s</p>", string)
end
#--------------------------------------------------------------------------
# ** Footer
#--------------------------------------------------------------------------
def foot
"</div>"
end
end
#==============================================================================
# ** EventPrinter Scene
#------------------------------------------------------------------------------
# This class handle mode selection for EventPrinter
#==============================================================================
class Scene < Scene_Base
#--------------------------------------------------------------------------
# * Start processing
# ** from => :title (returns to Scene_Title)
# :map (returns to Scene_Map)
#--------------------------------------------------------------------------
def start
super
initialize_data
@title_window = Window_Help.new(1)
@event_window = EventPrinter::Windows::Events.new @title_window
@page_window = EventPrinter::Windows::Pages.new @title_window
@map_window = EventPrinter::Windows::Maps.new @title_window
create_type_window
create_mode_window
end
#--------------------------------------------------------------------------
# ** Create type window
#--------------------------------------------------------------------------
def create_type_window
@type_window = EventPrinter::Windows::Types.new @title_window
lam = ->(type){fill_event_window(type)}
EventPrinter::Vocab::Windows::Types.each do |symbol, _|
@type_window.set_handler(symbol, ->{lam.curry.(symbol)})
end
@type_window.set_handler(:cancel, -> {Sound.play_cancel;@type_window.hide;@map_window.activate})
end
#--------------------------------------------------------------------------
# ** Create mode window
# ** Create mode window
#--------------------------------------------------------------------------
def create_mode_window
@mode_window = EventPrinter::Windows::Modes.new @title_window
lam = ->(action){do_action(action)}
EventPrinter::Vocab::Windows::Modes.each do |symbol, _|
@mode_window.set_handler(symbol, ->{lam.curry.(symbol)})
end
@mode_window.set_handler(:cancel, -> {
Sound.play_cancel
(@type_window.index == 1 ? @event_window : @page_window).activate
@mode_window.hide
})
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
if @map_window.active
update_map_window
elsif @event_window.active
update_event_window
elsif @page_window.active
update_page_window
end
end
#--------------------------------------------------------------------------
# ** Update for map window
#--------------------------------------------------------------------------
def update_map_window
if Input.trigger?(Input::B)
Sound.play_cancel
return_scene
elsif Input.trigger?(Input::C)
Sound.play_ok
@type_window.show.activate
@map_window.deactivate
end
end
#--------------------------------------------------------------------------
# ** Update for event window
#--------------------------------------------------------------------------
def update_event_window
if Input.trigger?(Input::B)
Sound.play_cancel
@map_window.show
@type_window.show.activate
@event_window.hide.deactivate
elsif Input.trigger?(Input::C)
Sound.play_ok
unless @type_window.index == 1
fill_page_window
@event_window.hide.deactivate
else
@mode_window.show.activate
@event_window.deactivate
end
end
end
#--------------------------------------------------------------------------
# ** Update for page window
#--------------------------------------------------------------------------
def update_page_window
if Input.trigger?(Input::B)
Sound.play_cancel
@event_window.show.activate
@page_window.hide.deactivate
elsif Input.trigger?(Input::C)
Sound.play_ok
@mode_window.show.activate
@page_window.deactivate
end
end
#--------------------------------------------------------------------------
# ** Filling event window
#--------------------------------------------------------------------------
def fill_event_window(type)
case type
when :map
map = get_map(@map_window.current_map_id)
@event_window.fill_with map.events.map { |e| {id: e[1].id, name: e[1].name }}
when :common
@event_window.fill_with(@data[:common_event][1..-1].map do |e|
{id: e.id, name: e.name }
end)
when :battle
@event_window.fill_with @data[:troops][1..-1].map { |e| {id: e.id, name: e.name }}
end
@event_window.show.activate.refresh
@type_window.hide
@map_window.hide
end
#--------------------------------------------------------------------------
# ** Filling page window
#--------------------------------------------------------------------------
def fill_page_window
case @type_window.index
when 0
map = get_map(@map_window.current_map_id)
@page_window.item_max = map.events[@event_window.current_event_id].pages.size
when 2
@page_window.item_max = @data[:troops][@event_window.current_event_id].pages.size
end
@page_window.show.activate.refresh
@page_window.select 0
end
#--------------------------------------------------------------------------
# ** Execute action
#--------------------------------------------------------------------------
def do_action(action)
event_classes = {map: EventPrinter::Event, common: EventPrinter::CommonEvent, battle: EventPrinter::BattleEvent}
event_class = event_classes[@type_window.current_symbol]
event = event_class.build(@event_window.current_event_id, @map_window.current_map_id)
event.send(action, @page_window.index)
@mode_window.activate
end
#--------------------------------------------------------------------------
# ** Load useful data
#--------------------------------------------------------------------------
def initialize_data
@data = {
:troops => load_data("Data/Troops.rvdata2"),
:common_event => load_data("Data/CommonEvents.rvdata2"),
:maps => {}
}
end
#--------------------------------------------------------------------------
# ** Load useful data
#--------------------------------------------------------------------------
def get_map(id)
@data[:maps][id] ||= load_data(sprintf("Data/Map%03d.rvdata2", id))
end
end
# End of Scene ------------------------------------------------------------------------------------------------
#==============================================================================
# ** Windows for EventPrinter Scene
#==============================================================================
module Windows
#===============================================================
class Maps < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
def initialize(help_window)
@help_window = help_window
fill
super(0, line_height + (standard_padding*2), Graphics.width,
Graphics.height - (line_height + (standard_padding*2)))
activate.refresh
select(0)
end
#--------------------------------------------------------------------------
# * Fill window
#-------------------------------------------------------------------------
def fill
@data = []
load_data("Data/MapInfos.rvdata2").map do |key, map|
@data.push name: sprintf("[%03d]%s", key, map.name), id: key
end
end
#--------------------------------------------------------------------------
# * Get Number of Items
#--------------------------------------------------------------------------
def item_max
return @data.size
end
#--------------------------------------------------------------------------
# * Get Digit Count
#--------------------------------------------------------------------------
def col_max
return 3
end
#--------------------------------------------------------------------------
# * Get current map id
#--------------------------------------------------------------------------
def current_map_id
return @data[@index][:id]
end
#--------------------------------------------------------------------------
# * Draw Item
#--------------------------------------------------------------------------
def draw_item(index)
change_color(normal_color)
draw_text(item_rect_for_text(index), @data[index][:name])
end
#--------------------------------------------------------------------------
# * Update help Window
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(EventPrinter::Vocab::Windows::Helper[0])
end
end
#===============================================================
class Types < Window_Command
#--------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
def initialize(help_window)
@help_window = help_window
super((Graphics.width - window_width) / 2, Graphics.height / 3)
hide.deactivate
end
#--------------------------------------------------------------------------
# * Create Command List
#--------------------------------------------------------------------------
def make_command_list
EventPrinter::Vocab::Windows::Types.each do |symbol, name|
add_command(name, symbol)
end
end
#--------------------------------------------------------------------------
# * Get Window Width
#--------------------------------------------------------------------------
def window_width
return Graphics.width / 2
end
#--------------------------------------------------------------------------
# * Update help Window
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(EventPrinter::Vocab::Windows::Helper[1])
end
end
#===============================================================
class Events < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
def initialize(help_window)
@help_window = help_window
@data = []
super(0, line_height + (standard_padding*2), Graphics.width,
Graphics.height - (line_height + (standard_padding*2)))
hide.deactivate
end
#--------------------------------------------------------------------------
# * Fill window
#-------------------------------------------------------------------------
def fill_with(data)
@data = data
select 0
end
#--------------------------------------------------------------------------
# * Get Number of Items
#--------------------------------------------------------------------------
def item_max
return @data.size
end
#--------------------------------------------------------------------------
# * Get Digit Count
#--------------------------------------------------------------------------
def col_max
return 3
end
#--------------------------------------------------------------------------
# * Get current map id
#--------------------------------------------------------------------------
def current_event_id
return @data[@index][:id]
end
#--------------------------------------------------------------------------
# * Draw Item
#--------------------------------------------------------------------------
def draw_item(index)
elt = @data[index]
change_color(normal_color)
draw_text(item_rect_for_text(index), sprintf(EventPrinter::Vocab::Windows::EventName, elt[:id], elt[:name] ))
end
#--------------------------------------------------------------------------
# * Update help Window
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(EventPrinter::Vocab::Windows::Helper[2])
end
end
#===============================================================
class Pages < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
def initialize(help_window)
@help_window = help_window
@item_max = 0
super(0, line_height + (standard_padding*2), Graphics.width,
Graphics.height - (line_height + (standard_padding*2)))
hide.deactivate
end
#--------------------------------------------------------------------------
# * Get Number of Items
#--------------------------------------------------------------------------
def item_max
@item_max
end
#--------------------------------------------------------------------------
# * Set Number of Items
#--------------------------------------------------------------------------
def item_max=(value)
@item_max = value
end
#--------------------------------------------------------------------------
# * Get Digit Count
#--------------------------------------------------------------------------
def col_max
return 3
end
#--------------------------------------------------------------------------
# * Draw Item
#--------------------------------------------------------------------------
def draw_item(index)
change_color(normal_color)
draw_text(item_rect_for_text(index), sprintf(EventPrinter::Vocab::Windows::PageName, index+1))
end
#--------------------------------------------------------------------------
# * Update help Window
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(EventPrinter::Vocab::Windows::Helper[3])
end
end
#===============================================================
class Modes < Window_Command
#--------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
def initialize(help_window)
@help_window = help_window
super(0, Graphics.height / 4)
hide.deactivate
end
#--------------------------------------------------------------------------
# * Create Command List
#--------------------------------------------------------------------------
def make_command_list
EventPrinter::Vocab::Windows::Modes.each do |symbol, name|
add_command(name, symbol)
end
end
#--------------------------------------------------------------------------
# * Get Window Width
#--------------------------------------------------------------------------
def window_width
return Graphics.width
end
#--------------------------------------------------------------------------
# * Calculate Height of Window Suited to Specified Number of Lines
#--------------------------------------------------------------------------
def fitting_height(line_number)
(line_number/2) * line_height + standard_padding * 2
end
#--------------------------------------------------------------------------
# * Get Digit Count
#--------------------------------------------------------------------------
def col_max
return 2
end
#--------------------------------------------------------------------------
# * Update help Window
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(EventPrinter::Vocab::Windows::Helper[4])
end
end
end
# End of Windows ------------------------------------------------------------------------------------------------
end
#==============================================================================
# ** RPG::AudioFile
#==============================================================================
class RPG::AudioFile
#--------------------------------------------------------------------------
# * From RPG::AudioFile to string
#--------------------------------------------------------------------------
def to_string_params
name.empty? ? EventPrinter::Vocab::None : sprintf(EventPrinter::Vocab::Music, *[name, volume, pitch])
end
end
#==============================================================================
# ** RPG::MoveRoute
#==============================================================================
class RPG::MoveRoute
#--------------------------------------------------------------------------
# * From RPG::MoveRoute to string
#--------------------------------------------------------------------------
def to_string_params
params = []
params << EventPrinter::Vocab::MoveRouteParams[0] if @repeat
params << EventPrinter::Vocab::MoveRouteParams[1] if @skippable
params << EventPrinter::Vocab::MoveRouteParams[2] if @wait
params.empty? ? "" : sprintf("(%s)", params.join(", "))
end
end
#==============================================================================
# ** RPG::MoveCommand
#==============================================================================
class RPG::MoveCommand
#--------------------------------------------------------------------------
# * Hash for special moving commands
#--------------------------------------------------------------------------
SpecialMoveCommand = {
41 => ->(params){ params[0] == "" ? [EventPrinter::Vocab::None] : "'#{params[0]}', #{params[1]}"},
43 => ->(params){ [EventPrinter::Vocab::Transparency[params[0]]] },
44 => ->(params){ params[0].to_string_params }
}
#--------------------------------------------------------------------------
# * From RPG::MoveCommand to array
#--------------------------------------------------------------------------
def to_params
(SpecialMoveCommand.fetch(@code) { ->(params){ params } }).call(@parameters)
end
end
#==============================================================================
# ** Color
#==============================================================================
class Color
#--------------------------------------------------------------------------
# * From Color to string
#--------------------------------------------------------------------------
def to_string_params(with_alpha = true)
sprintf(EventPrinter::Vocab::Color[with_alpha ? 0 : 1], red, green, blue, alpha)
end
end
#==============================================================================
# ** Tone
#==============================================================================
class Tone
#--------------------------------------------------------------------------
# * From Tone to string
#--------------------------------------------------------------------------
def to_string_params
sprintf(EventPrinter::Vocab::Tone, red, green, blue, gray)
end
end
#==============================================================================
# ** Win32API (Thx Grim)
#==============================================================================
class Win32API
#--------------------------------------------------------------------------
# * Librairy
#--------------------------------------------------------------------------
CloseClipboard = self.new('user32', 'CloseClipboard', 'v', 'i')
EmptyClipboard = self.new('user32', 'EmptyClipboard', 'v', 'i')
EnumClipboardFormats = self.new('user32', 'EnumClipboardFormats','i', 'i')
GetClipboardData = self.new('user32', 'GetClipboardData', 'i', 'i')
GetClipboardFormatName = self.new('user32', 'GetClipboardFormatName', 'ipi', 'i')
GlobalAlloc = self.new('kernel32', 'GlobalAlloc', 'ii', 'i')
GlobalFree = self.new('kernel32', 'GlobalFree', 'i', 'i')
GlobalLock = self.new('kernel32', 'GlobalLock', 'i', 'l')
Memcpy = self.new('msvcrt','memcpy', 'ipi', 'i')
MultiByteToWideChar = self.new('kernel32', 'MultiByteToWideChar', 'ilpipi', 'i')
OpenClipboard = self.new('user32', 'OpenClipboard', 'i', 'i')
RegisterClipboardFormat = self.new('user32', 'RegisterClipboardFormat', 'p', 'i')
SetClipboardData = self.new('user32', 'SetClipboardData', 'ii', 'i')
WideCharToMultiByte = self.new('kernel32', 'WideCharToMultiByte', 'ilpipipp', 'i')
#--------------------------------------------------------------------------
# * Singleton
#--------------------------------------------------------------------------
class << self
#--------------------------------------------------------------------------
# * convert text
#--------------------------------------------------------------------------
def convert_text(text, from, to)
size = MultiByteToWideChar.call(from, 0, text, -1, nil, 0)
buffer = [].pack("x#{size*2}")
MultiByteToWideChar.call(from, 0, text, -1, buffer, buffer.size/2)
size = WideCharToMultiByte.call(to, 0, buffer, -1, nil, 0, nil, nil)
second_buffer = [].pack("x#{size}")
WideCharToMultiByte.call(to, 0, buffer, -1, second_buffer, second_buffer.size, nil, nil)
second_buffer.delete!("\000") if to == 65001
second_buffer.delete!("\x00") if to == 0
return second_buffer
end
#--------------------------------------------------------------------------
# * Push text in clipboard
#--------------------------------------------------------------------------
def push_text_in_clipboard(text)
OpenClipboard.call(0)
EmptyClipboard.call()
hmem = GlobalAlloc.call(0x42, text.length)
mem = GlobalLock.call(hmem)
Memcpy.call(mem, text, text.length)
SetClipboardData.call(1, hmem) # Format CF_TEXT = 1
GlobalFree.call(hmem)
CloseClipboard.call()
self
end
end
end
#==============================================================================
# ** String
#------------------------------------------------------------------------------
# A String object holds and manipulates an arbitrary sequence of bytes,
# typically representing characters.
#==============================================================================
class String
#--------------------------------------------------------------------------
# * return self in ASCII-8BIT
#--------------------------------------------------------------------------
def to_ascii; Win32API.convert_text(self, 65001, 0);end
#--------------------------------------------------------------------------
# * convert self in ASCII-8BIT
#--------------------------------------------------------------------------
def to_ascii!; self.replace(self.to_ascii); end
end
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
# This class performs the title screen processing.
#==============================================================================
class Scene_Title
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
alias old_update update
def update
old_update
DataManager.load_database
if Input.trigger?(Input::F5)
SceneManager.call(EventPrinter::Scene)
end
end
end
end