What is Cecilia:

Cecilia is meant to be an in-game manager and a back-end helper for the programmer/scripter. She is meant to serve as the basis for more interesting plugins in the future. Things that work only for the system itself. And others, that work for the developer, developing new things for her under the hood. For now, there is functionality that a developer can definitely use, which is the column-based windows. This base plugin allows for the creation of a host of plugins that can be used by other people who want touch-based menus among other things.

Version 1.04

Core Features

  • Windows you can drag around the screen.
  • Window creation on any scene.
  • Touch Input based windows
  • Row and column based (Think Twitter Bootstrap) windows
  • Binding events / actions to a window’s column
  • Timers (You can create timers and start them when you want to, providing them with a call back function for what you want them to do).
  • Filters (A wrapper class for PIXI.Filters, so you don’t have to look around for their names if you want to use them)
  • Adding filters to Cecilia_Windows
  • Aliasing / Adding Modules to the system (This is mainly for developer convenience) to keep track of different namespaces when creating plugins.
    • When using modules, you can use all the methods / functions provided by the namespace
  • Cecilia Speak (A simple use of the message window, where Cecilia will speak with the text you want in the window).
  • File Writing (You can write, or append to a JSON file, or even write a .txt file if you want)
    • You can also call that data back to you, and take a look at it in the dev console.

Planned Features / Plugins

  • Functioning in-game AI (Although it’s pretty possible to do such things via events)
  • Equipment for Cecilia that adds buffs / debuffs to the party (risk reward kind of system for changing the way the game is played).

Important Information

This is my first time building a script / plugin of this size, and also one that is functioning only as a base module. As a result, this system, and this module is a base for more plugins in the future that can utilize the functionality here; this module will also be updated to improve the basic functionality.

Things such as a better implementation of the message window used for outputting messages.


Download “EIS File System”

EISFileSystem.js – Downloaded 1707 times –

Download “Cecilia”

Cecilia_Heart.js – Downloaded 1219 times –


  1. Download both Cecilia_Heart.js and EISFileSystem.js
  2. Place the scripts in your plugins folder with the same name Cecilia_Heart
  3. In your PluginManager, place Cecilia_Heart below EISFileSystem.
  4. Enjoy

Video Of Functionality

Methods / Functions

There are a lot, so please read the help included to get detailed information on all the things you can do.

Below is a copy of the help contents.

//  Cecilia System
* This is the basic module of Cecilia, and it will be improved over time.
* It's a system I designed to help players, and also developers with creating
* the game they want. With a couple of cool features.
* She is an Automated System that talks to the player.
//  API Interface
* Cecilia has a list of functions/methods that you can use via her namespace.
* The below are the list of functions that you can use with the new classes
* within the system.
//  Cecilia Speak
* Cecilia.speak(string)
* Creates a message window with the specified string inside in pink.
* Cecilia.speakIntrusive(string)
* Creates a message window, but the player can't move while the window is open.
//  Cecilia Modules
* Cecilia.addModule(name, module)
* Aliases a module, or another plugin's scripts APIs so you can use them with
* a convenient name.
* Cecilia.module(name)
* Calls the aliased module, so that you can access the exports inside of it.
* Cecilia.modules()
* Lists all the modules that you've added to Cecilia inside of the dev console
* along with their functions / methods.
//  Cecilia Timers
* Cecilia can create Timers, that you have some control over.
* These timers are in seconds, and they can activate some function or method
* after some amount of time. This is great, because you can delay some effect
* until your timer runs out. Plus, you can have as many as you want.
* There also two types of timers. Both work similarly, except one uses in game
* frames, and the other one uses the current date for calculating the timer time.
* Cecilia.createTimer(seconds, callback)
* - Creates a timer that will activate your callback function after a certain
* amount of seconds.
* Once you create a timer, you have access to a couple of functions, which I
* will show using this example.
* var timer = Cecilia.createTimer(20, function(){ console.log("Hello World")});
* We have now created a timer that will output hello world to the console once
* we start it.
* timer.startGTimer()
* This will start our newly created timer and start counting down the time using
* the games frames.
* timer.startTimer()
* This will count down the timer's time using real time / seconds instead.
* But, you can do a bit more, you can set the timers even after you created
* them.
* timer.setTimer(seconds)
* This will set the timer to the amount of seconds you specify.
* timer.setGTimer(seconds);
* This will set the gTimer to the amount you specify in seconds.
//  Cecilia.Filters
* Container  for PIXI filters under a common name space
* Filter Documentation: https://pixijs.github.io/docs/PIXI.filters.html
* Filter Types
* ------------------------------------------------------------------------------
* RGB - Splits the Colors into RGB.
* Dot - Creates a black and white dot effect over the window contents.
* CrossHatch - Creates a cross hatch effect on the window.
* Sepia - Adds a sepia effect to the window.
* Gray - Adds gray to the window.
* Pixel - Pixelates the window.
* Invert - Inverts the window.
* Blur - Blurs the contents of the window.
* Twist - Twists the window contents.
* Displacement - Displaces sections of the window.
* ColorStep - Steps through the color in the window.
//  Cecilia Windows
* Cecilia windows are different from regualr windows you must be used to.
* Cecilia windows are touch input based windows; you can only access them with
* touch inputs.
* They are also draggable and have new methods that go along with them.
* These windows are also defined by a column and row layout that allows for
* greater flexibility and positioning when creating a window.
* Furthermore, Cecilia windows can be added to any scene in the game.
* As long as you can run some code to get it setup, you can put one
* on any kind of scene that is a child of Scene_Base.
* I will demonstrate the core functionality in the example below:
* Creating a window
* ------------------------------------------------------------------------------
* var clWindow = Cecilia.createCLIWindow(x, y , width, height);
* clWindow.createRow( 300 ) [Width]
* This creates a new window row, expanding the window to fit that size.
* clWindow.createColumn(1, 100,) [Row index, width, height]
* This crreates a new window column, expanding the window to be 300 by 100
* and the column itself only takes up 100 / 300 of the windows width.
* clWindow.addFilters(new Cecilia.Filters.Dot()) [PIXI.Filters]
* This adds a new filter to the created window, changing it's appearance.
* clWindow.bindAction(1, 1, "Cecilia.speakIntrusive('Hello to all of you')")
* This methods binds an action to the column, that the user can click on.
* Once clicked in this case, Cecilia will say Hello.
* clWindow.clearColumn(1, 1) [rowIndex, columnIndex]
* Clears a single column within the first row.
* clWindow.clearColumns(1) [rowIndex]
* This method clears all the columns within a row.
* In this case, it would be clearing all the columns in row 1.
* clWindow.clearRow(1) [rowIndex]
* Clears an entire row for a window. In this case, clearing all of row 1.
//  Cecilia Data Structures
* -- Experimental
* The system has a list of data structures that a dev can use.
* These include things like linked lists and tree structures that you can
* create for your own personal use when setting up some sort of new module /
* plugin using the Cecilia System as the base.
* Linked List Notes
* ------------------------------------------------------------------------------
* Linked Lists are different from arrays, the key difference is that you can
* access the elements of a linked list by searching through the entire list.
* This is the key difference between an array, and a linked list.
* The other difference is that a linked list keeps track of each
* node in the list. What does that mean? You can follow the links
* to see what comes next in the list.
* Each of these create methods can take any amount of data. This means
* you're free to add as many links to the list as you want.
* Cecilia.DataStructs.createLL()
* This creates a single linked list.
* Example: Cecilia.DataStructs.createLL(1, 2, 3, "Test Data");
* Each one of the passed parameters becomes a link along the list.
* This is true for the other methods too.
* Cecilia.DataStructs.createCLL()
* This creates a circular linked list structure; this structure is special,
* because you can create rotations using this structure without checking for
* things such as null values, or going through a for loop.
* Cecilia.DataStructs.createDLL()
* This creates a doubled linked list; this kind of list you can either go from
* the front or the back, which means it can be faster than an array for searching
* for data that you might want to keep in memory.

As you can see the screen has been lightened up a little.


Free for both commercial and non-commercial use.
Credit with the name Kino or Endless Illusion Software.

I appreciate you using this script, and I’m glad that it’s able to help you; it was fun working on this project personally.

If you have any ideas, please feel free to mention them here. This system is a constant work in progress and will be updated only to make it better for the end-user.

%d bloggers like this: