/*:
* @plugindesc Adds Intel-Gathering funcionality: itemized intel, checks for
* event handling, and a menu for viewing collected Intel.
* @author Camkitsune
*
* @param JsonFileName
* @desc Filename for the JSON file containing the intel data.
* @default 'Intel.json'
*
* @param ShowAlerts
* @desc Boolean toggles whether or not alert messages appear on intel gain/
* update; functionality currently not implemeneted.
* @default false;
*
* @help
* BETA VERSION
* ------------ABOUT------------------------------------------------------------
* This plugin adds an Intel-gathering feature to RPG Maker MV: it keeps a
* list of user-defined itemized information on specific topics that can be
* viewed via an option in the Menu.
* Individual items can have multiple notes added at different times according
* to the arguments given. The presence of certain Intel items can be checked
*
* For flexibility and maintainability, the actual data for intelItems is to be
* saved in a separate JSON file in the data folder.
*
* ------------COMMANDS---------------------------------------------------------
* Plugin commands take the format below:
* IntelPlugin("command", ["id", "contents# contents#"])
*
* "command" should be either "add" to insert a new intel item (or update one
* the player already has), or "check" to determine whether the player has the
* intel required to activate an event switch.
*
* "id" is a string form of the id number of the intel file you want to use for
* the command.
*
* the second string is used to determine which items from the contents array
* you want to use for the command. These arrays start at zero; negatives and
* numbers greater than the number of contents will be ignored. For "check"
* commands an empty string can be used to simply check for the topic.
*
* ------------ITEM PARAMETERS--------------------------------------------------
* Each Itel item has three parameters:
* Category = the Category the item will belong to. Items can currently only
* have one category.
* Topic = What the Contents will appear under when looked up in the menu. Two
* items cannot have the same topic; using identical topics for multiple items
* will result in their contents being merged.
* Contents = all text that will appear under the specified topic, arranged into
* an array. Individual lines are intended to serve as seperate bits that will
* be added similarly.
*
*
* --------------WRITING JSON---------------------------------------------------
* The json file needs to be layed out as follows:
* [
* null,
* {"id":1, "topic":"topic1 name", "category":"topic1 category", "contents":["topic1 contents 1", "topic1 contents 2", ...]},
* {"id":2, "topic":"topic2 name", "category":"topic2 category", "contents":["topic2 contents 1", "topic2 contents 2", ...]},
* {"id":3, "topic":"topic3 name", ...
* ... "topic# contents#]}
* ]
* Items will be added in the order they are written; their position in the
order doubles as the item's ID number.
*
* --------------PLUGIN PARAMETERS----------------------------------------------
* INTELJSON = filename for JSON file; file MUST be located in the data folder
* with the other JSON objects. Defaults to Intel.json
* SHOWALERTS = toggles whether or not the game will display alert messages when
* items are added/updated.
*
*
* ------------COMPATABILITY----------------------------------------------------
* The current version overwrites the functions that populate the Main Menu's
* Command list; any other plugins that do this will most likely not work.
* Compatability with YanflyEngine's Main Menu Manager pending.
*/
Game_Interpreter.prototype.IntelPlugin(function(original){
"use strict";
/*----------------------------------------------------------------------------*
* PLUGIN SETUP *
*----------------------------------------------------------------------------*/
//Get the plugin parameters.
var intelParameters = PluginManager.paramters('IntelSystem');
//Get the intel data.
DataManager.loadDataFile('$dataIntel', String(intelParameters.JsonFileName));
DataManager.getIntelData = function(id) {
return this._dataIntel[id];
};
//Define core plugin command.
function IntelPlugin(command, args) {
original.call(this, command, args);
//Get the intel item from the database.
var intelArg = GetIntelData(args);
//Determine which of the two core functions to use.
if (intelArg && command == "add") {
$gameParty.addIntel(intelArg);
//TODO: Add popup window announcing whether intel was added/updated.
} else if (intelArg && command == "check") {
return $gameParty.hasIntel(intelArg);
} else {
return;
}
}
//Function fetches an intelItem for use by the command.
function GetIntelData(args) {
try {
var idNum = Number(args[0]);
var intelFromData = DataManager.getIntelData(idNum);
var contentIds = args[1].split(" ");
var contents = [];
while (contentIds.length > 0) {
var contentsIndex = Number(contentIds.shift);
//If contentsIndex is a valid number, AND the number is within the contents array, AND the item hasn't already been added...
if (!NaN(contentsIndex) && contentsIndex < intelFromData.contents.length && contents.indexOf(intelFromData.contents[contentsIndex]) === -1) {
//...Add the contents item
contents.push(intelFromData.contents[contentsIndex]);
}
}
return new IntelItem(idNum, intelFromData.topic, intelFromData.category, contents);
} catch (err) {
console.log("Intel plugin ran into problems getting the following data: " + args);
return null;
}
}
/*----------------------------------------------------------------------------*
* CORE FUNCTIONS *
*----------------------------------------------------------------------------*/
//Object constructor for IntelItem.
function IntelItem(idnum, topic, category, contents) {
//ID is used to simplify the lookup process.
this.id = idnum;
//Topics are what the specific informatoin will appear on: IE, the subject of the intel.
this.topic = topic;
//Categories are used for in-game filtering.
this.category = category;
//Array representing specific lines of information.
this.contents = contents;
}
//Function is used as part of evaluation of whether a new intel item's contents are already in the player's Intel inventory.
IntelItem.prototype.matches = function (intelFromList) {
var index = 0;
//isMatch first checks if the topics match; while loop won't even start if they don't.
var isMatch = (this.id === intelFromList.id);
while (isMatch && index < this.contents.length) {
//Step through the contents of the calling IntelItem; if the IntelItem from the list is missing any of them, return false.
isMatch = (intelFromList.contents.indexOf(this.contents[index]) > -1);
index++;
}
return isMatch;
};
//Function adds contents FROM the calling function TO the item given as an argument; the intent is that the item passed as an argument accesses the info from intelList.
IntelItem.prototype.addNewContents = function(intelFromList){
var newContentsAdded = false;
for (var index = 0; index < this.contents.length; index++) {
if (intelFromList.contents.indexOf(this.contents[index]) === -1) {
intelFromList.contents.push(this.contents[index]);
newContentsAdded = true;
}
}
return newContentsAdded;
};
//Function returns the IntelItem.contents array as a single formated string, ready to be written into the menu.
IntelItem.prototype.getContents = function(){
var result = "";
for (var x = 0; x < this.contents.length; x++) {
result += " " + this.contents[x];
}
return result;
};
//IntelList handles in-game inventory of IntelItems, provides sorting functionality.
function intelList() {
this.IntelItems = [];
this.intelCategories = [];
}
//Function updates the intel listing with new items, new categories, and new contents for extant items.
//Returns a string for use with alerts.
intelList.prototype.addIntel = function(targetIntel) {
//Insert category if it isn't in the categories list.
if (this.intelCategories.indexOf(targetIntel.category) === -1) {
this.intelCategories.push(targetIntel.category);
this.intelCategories.sort();
}
var result = null;
var dexVal = this.findIndex(targetIntel);
if (dexVal === this.IntelItems.length) {
this.IntelItems.push(targetIntel);
result = "New intelligence file: " + targetIntel.topic;
} else {
var intelAtIndex = this.IntelItems[dexVal];
if (intelAtIndex.id != targetIntel.id) {
this.IntelItems.splice(dexVal+ 1, 0, targetIntel);
result = "New intelligence file: " + targetIntel.topic;
} else {
var contentsCheck = targetIntel.addNewContents(intelAtIndex);
if (contentsCheck){
result = "Information updated: " + targetIntel.topic;
}
}
}
if (intelParameters.ShowAlerts) {
return result;
} else {
return null;
}
};
//Helper function for addIntel function; makes sure new intel is inserted alphabetically.
intelList.prototype.findIndex = function (targetIntel) {
var index = 0;
var resultVal = 1;
while (index < this.IntelItems.length && resultVal < 0) {
resultVal = targetIntel.topic.localeCompare(this.IntelItems[index].topic);
if (resultVal > 0) { index++; }
}
return index;
};
intelList.prototype.hasIntel = function(targetIntel) {
//searchFunction must be defined this way due to how Array.some handles the function.
var searchFunction = function(intelFromList){
//The IntelItem.matches function checks to see if the intel item taken from the list has the same ID as well as all of the contents it has.
return targetIntel.matches(intelFromList);
};
return this.IntelItems.some(searchFunction);
};
//Returns an array of IntelItems with the specified topic.
intelList.prototype.getIntelFromCategory = function(categoryName){
var result = [];
for (var index = 0; index < this.IntelItems.length; index++) {
if (this.IntelItems[index].category === categoryName) {
result.push(this.IntelItems[index]);
}
}
return result;
};
//Attach IntelList to the Party object on initialization.
Game_Party.prototype.initialize = function() {
Game_Unit.prototype.initialize.call(this);
this._gold = 0;
this._steps = 0;
this._lastItem = new Game_Item();
this._intelList = new intelList();
this._menuActorId = 0;
this._targetActorId = 0;
this._actors = [];
this.initAllItems();
};
//Methods for accessing data from intelList
//Return all Intel items in the list.
Game_Party.prototype.getAllIntel = function() {
return this._intelList.IntelItems;
};
//Returns the categories
Game_Party.prototype.getIntelCategories = function() {
return this._intelList.intelCategories;
};
//returns a string for an in-game message if the intel was added successfully.
Game_Party.prototype.addIntel = function(targetIntel){
return this._intelList.addIntel(targetIntel);
};
//Used for event flags.
Game_Party.prototype.hasIntel = function(targetIntel){
return this._intelList.hasIntel(targetIntel);
};
//Return all Intel items with the specified category.
Game_Party.prototype.getIntelFromCategory = function(category) {
return this._intelList.getIntelFromCategory(category);
};
}(Game_Interpreter.prototype.IntelPlugin));
