junebug12851 / pokered-mon-database

src/index.js

/****
 * This module creates an in-memory Pokemon Database for Generation 1 Games
 * It uses a very small memory footprint and speedy-quick navigation
 * This happens through circular references which come with a lot of pitfalls
 *      * Make sure to only keep a single instance of this in memory, Javascript
 *        has a lot of issues with garbage collecting circular references.
 *      * If deep navigating the database, be very careful about not ending up
 *        in infinite loops.
 *      * You cannot use JSON.stringify or certain other tools, at least not
 *        without some careful prep work beforehand
 *
 * This was created initially for the Pokered Save Editor which works just fine
 * with the pitfalls of circular references but for other uses caution may need
 * to be taken.
 */

// Import Dependencies
const _ = require("lodash");

// Import Raw JSON Files
const itemsRaw = require("./data/items.json");
const movesRaw = require("./data/moves.json");
const pokemonRaw = require("./data/pokemon.json");
const typesRaw = require("./data/types.json");

// Class Constructor
// Initiate Array
const PokeredMonDB = exports.PokeredMonDB = function() {

    // Do initial build
    this.rebuild();
}

// Build or Rebuild database
// This should normally never need to be called manually
// and is provided for special edge cases. Keep in mind calling this again
// might create memory leaks in certain browsers due to circular references.
PokeredMonDB.prototype.rebuild = function() {
    
    // Rr-create array
    this.items = [];
    this.moves = [];
    this.pokemon = [];
    this.types = [];

    // Setup primary index to be the internal index number
    this._indexPrimary(this.itemsRaw, this.items, "ind");
    this._indexPrimary(this.movesRaw, this.moves, "ind");
    this._indexPrimary(this.pokemonRaw, this.pokemon, "ind");
    this._indexPrimary(this.typesRaw, this.types, "ind");

    // Add in aliases for names as-is
    this._indexSecondary(this.itemsRaw, this.items, "name", "ind");
    this._indexSecondary(this.movesRaw, this.moves, "name", "ind");
    this._indexSecondary(this.pokemonRaw, this.pokemon, "name", "ind");
    this._indexSecondary(this.typesRaw, this.types, "name", "ind");

    // Add in aliases for names in snake_case form
    this._indexSecondarySnake(this.itemsRaw, this.items, "name", "ind");
    this._indexSecondarySnake(this.movesRaw, this.moves, "name", "ind");
    this._indexSecondarySnake(this.pokemonRaw, this.pokemon, "name", "ind");
    this._indexSecondarySnake(this.typesRaw, this.types, "name", "ind");

    // Add in aliases prefixed
    this._indexSecondaryPrefix(this.itemsRaw, this.items, "tm", "ind");
    this._indexSecondaryPrefix(this.itemsRaw, this.items, "hm", "ind");

    this._indexSecondaryPrefix(this.movesRaw, this.moves, "tm", "ind");
    this._indexSecondaryPrefix(this.movesRaw, this.moves, "hm", "ind");

    this._indexSecondaryPrefix(this.pokemonRaw, this.pokemon, "pokedex", "ind");

    // Circular Link everything
    this._processAllItems();
    this._processAllMoves();
    this._processAllPokemon();
}

// Indexes all items by deep cloning each item and adding it to the object under key value
PokeredMonDB.prototype._indexPrimary = function(from, to, key) {
    this._iterate(from, function(entry) {
        to[entry[key]] = _.cloneDeep(entry);
    });
}

// Creates a 2nd index which just aliases the first index
PokeredMonDB.prototype._indexSecondary = function(from, to, key, origKey) {
    this._iterate(from, function(entry) {
        to[entry[key]] = to[entry[origKey]];
    });
}

// Creates a 2nd index snake_case'd which just aliases the first index
PokeredMonDB.prototype._indexSecondarySnake = function(from, to, key, origKey) {
    this._iterate(from, function(entry) {
        to[_.snakeCase(entry[key])] = to[entry[origKey]];
    });
}

// Creates a 2nd index prefixed which just aliases the first index
// Only creates alias if key exists
PokeredMonDB.prototype._indexSecondaryPrefix = function(from, to, key, origKey) {
    this._iterate(from, function(entry) {
        if(entry[key] !== undefined)
            to['' + key + entry[key]] = to[entry[origKey]];
    });
}

// This interlinks certain item meta-data to other database entries
PokeredMonDB.prototype._processAllItems = function() {
    this._iterate(this.items, function(value) {
        this._processPrimitiveEntry(value, "tm", "tm", "moves", this);
        this._processPrimitiveEntry(value, "hm", "hm", "moves", this);
    });
}

// This interlinks certain move meta-data to other database entries
PokeredMonDB.prototype._processAllMoves = function() {
    this._iterate(this.moves, function(value) {
        this._processPrimitiveEntry(value, "type", "name", "types", this);
        this._processPrimitiveEntry(value, "tm", "_tm", "items", this);
        this._processPrimitiveEntry(value, "hm", "_hm", "items", this);
    });
}

// This interlinks certain pokemon meta-data to other database entries
PokeredMonDB.prototype._processAllPokemon = function() {
    this._iterate(this.pokemon, function(value) {

        this._iterate(value.moves, function(move) {
            this._processPrimitiveEntry(move, "move", "name", "moves", this);
        });

        this._processArrayEntry(value, "initial", "name", "moves", this);
        this._processArrayEntry(value, "tmHm", "_tm", "moves", this);

        this._processPrimitiveEntry(value, "type1", "name", "types", this);
        this._processPrimitiveEntry(value, "type2", "name", "types", this);

        this._processArrPrimEntry(value, "evolution", this._processEvolutionEntry);
    });
}

// This loops over an object or array if it's valid, checks each entry and calls a function
// if the entry is not defined. The function is binded to the class.
PokeredMonDB.prototype._iterate = function(v, fn) {
    _.each(v, function(value) {
        if(value === undefined)
            return;

Are you sure this return statement is not missing an argument? If this is intended, consider adding an explicit undefined like return undefined;.

        return fn.call(this, value);
    }.bind(this));
}

// This loops over an evolution pokemon database entry and proccesses it
PokeredMonDB.prototype._processEvolutionEntry = function(entry, value) {
    this._processPrimitiveEntry(entry, "item", "name", "items");

    // Intentional to simplify code below
    if(entry._toName !== undefined)
        return;

    this._processPrimitiveEntry(entry, "toName", "name", "pokemon");
    entry.toName.deEvolution = value;
}

// This loops over a simple array if it exists and inter-links valid elements to other data
PokeredMonDB.prototype._processArrayEntry = function(value, from, key, where) {
    if(value[from] !== undefined && value['_' + from] === undefined) {
        value['_' + from] = _.cloneDeep(value[from]);
        for(let i = 0; i < value[from].length; i++) {
            const val = value[from][i];
            value[from][i] = _.find(this[where], [key, val]);
        }
    }
}

// This interlinks primitive data to other data
PokeredMonDB.prototype._processPrimitiveEntry = function(value, from, key, where) {
    if(value[from] !== undefined && value["_" + from] === undefined) {
        value["_" + from] = value[from];
        value[from] = _.find(this[where], [key, value[from]]);
    }
}

// This interlinks a variable that could be an array or primitive and calls given function
// with each item and original object item came from
PokeredMonDB.prototype._processArrPrimEntry = function(value, from, fn) {
    if(Array.isArray(value[from])) {
        this._iterate(value[from], function(arrEntry) {
            fn.call(this, arrEntry, value);
        });
    }
    else if(value[from] !== undefined)
        fn.call(this, value[from], value);
}

// Add several ways to access the raw data, nothings duplicated because it's just all copying
// by reference
PokeredMonDB.itemsRaw = PokeredMonDB.prototype.itemsRaw = itemsRaw;
PokeredMonDB.movesRaw = PokeredMonDB.prototype.movesRaw = movesRaw;
PokeredMonDB.typesRaw = PokeredMonDB.prototype.typesRaw = typesRaw;
PokeredMonDB.pokemonRaw = PokeredMonDB.prototype.pokemonRaw = pokemonRaw;