entityidentifier.cpp

/** Copyright (c) 2014, EtlamGit */
#include <QDebug>
#include <assert.h>
#include "./entityidentifier.h"
#include "./json.h"

EntityInfo::EntityInfo(QString name, QString category, QColor brushColor,
                       QColor penColor) : name(name), category(category),
  brushColor(brushColor), penColor(penColor) {}

// dummy for entities not found in *_entity.json
static EntityInfo entityDummy("Name unknown", "Others",  // Name Category
                              Qt::black, Qt::black);     // Black circle with Black border


// --------- --------- --------- ---------
// EntityIdentifier
// --------- --------- --------- ---------

EntityIdentifier::EntityIdentifier() {}
EntityIdentifier::~EntityIdentifier() {}

EntityIdentifier& EntityIdentifier::Instance() {
  static EntityIdentifier singleton;
  return singleton;
}

void EntityIdentifier::enableDefinitions(int packID) {
  if (packID < 0) return;
  for (auto it = packs.begin(); it != packs.end(); ++it) {
    if (it->packID == packID) {
      it->enabled = true;
      return;
    }
  }
}

void EntityIdentifier::disableDefinitions(int packID) {
  if (packID < 0) return;
  for (auto it = packs.begin(); it != packs.end(); ++it) {
    if (it->packID == packID)
      it->enabled = false;
  }
}

int EntityIdentifier::addDefinitions(JSONArray *defs, int packID) {
  if (packID == -1) {
    // find largest used packID
    for (auto it = packs.constBegin(); it != packs.constEnd(); ++it) {
      if (it->packID > packID)
        packID = it->packID;
    }
    packID++;  // use one higher than largest found
    packs.append(TpackInfo(packID));
  }
  int len = defs->length();
  for (int i = 0; i < len; i++)
    parseCategoryDefinition(dynamic_cast<JSONObject *>(defs->at(i)), packID);
  return packID;
}

EntityIdentifier::TentityMap& EntityIdentifier::getMapForPackID(int packID) {
  for (auto it = packs.begin(); it != packs.end(); ++it) {
    if (it->packID == packID)
      return it->map;
  }
  return dummyMap;
}

void EntityIdentifier::parseCategoryDefinition(JSONObject *data, int packID) {
  QString category;
  if (data->has("category"))
    category = data->at("category")->asString();
  else
    category = "Unknown";

  QColor catcolor;
  if (data->has("catcolor")) {
    QString colorname = data->at("catcolor")->asString();
    catcolor.setNamedColor(colorname);
    assert(catcolor.isValid());
  } else {  // use hashed by name instead
    quint32 hue = qHash(category);
    catcolor.setHsv(hue % 360, 255, 255);
  }
  addCategory(qMakePair(category, catcolor));

  if (data->has("entity")) {
    JSONArray *entities = dynamic_cast<JSONArray *>(data->at("entity"));
    int len = entities->length();

    for (int e = 0; e < len; e++)
      parseEntityDefinition(dynamic_cast<JSONObject *>(entities->at(e)),
                            category, catcolor, packID);
  }
}

void EntityIdentifier::parseEntityDefinition(JSONObject *entity,
                                             QString const &category,
                                             QColor catcolor, int packID) {
  QString id("unknown");
  if (entity->has("id"))
    id = entity->at("id")->asString().toLower();

  if (entity->has("catcolor")) {
    QString colorname = entity->at("catcolor")->asString();
    catcolor.setNamedColor(colorname);
    assert(catcolor.isValid());
  }

  QColor color;
  if (entity->has("color")) {
    QString colorname = entity->at("color")->asString();
    color.setNamedColor(colorname);
    assert(color.isValid());
  } else {  // use hashed by name instead
    quint32 hue = qHash(id);
    color.setHsv(hue % 360, 255, 255);
  }

  QString name;
  if (entity->has("name")) {
    // use provided name
    name = entity->at("name")->asString();
  } else {
    // or try to build name automatically
    // split at underscores
    QStringList tokens = id.toLower().replace('_',' ').split(" ");
    // make first character uppercase
    for (QList<QString>::iterator tokItr = tokens.begin(); tokItr != tokens.end(); ++tokItr) {
      (*tokItr) = (*tokItr).at(0).toUpper() + (*tokItr).mid(1);
    }
    name = tokens.join(" ");
  }

  // enter entity into manager
  TentityMap& map = getMapForPackID(packID);
  map.insert(id, EntityInfo(name, category, catcolor, color));

  // add duplicates: when new 1.11+ or 1.13+ id definitions are available
  // legacy id is stored in own definition element (duplicates automatically)
  if (entity->has("idlist")) {
    JSONArray *idlist = dynamic_cast<JSONArray *>(entity->at("idlist"));
    int len = idlist->length();
    for (int j = 0; j < len; j++) {
      QString idl = entity->at("idlist")->at(j)->asString().toLower();
      map.insert(idl, EntityInfo(name, category, catcolor, color));
    }
  }
}

bool EntityIdentifier::addCategory(QPair<QString, QColor> cat) {
  for (auto it = categories.constBegin(); it != categories.constEnd(); ++it) {
    if (it->first == cat.first)
      return false;
  }
  categories.append(cat);
  return true;
}

int EntityIdentifier::getNumCategories() const {
  return categories.size();
}

EntityIdentifier::TcatList const &EntityIdentifier::getCategoryList() const {
  return categories;
}

QColor EntityIdentifier::getCategoryColor(const QString name) const {
  for (auto it = categories.constBegin(); it != categories.constEnd(); ++it) {
    if (it->first == name)
      return it->second;
  }
  return Qt::black;  // dummy
}

EntityInfo const &EntityIdentifier::getEntityInfo(const QString id) const {
  for (auto it = packs.constBegin(); it != packs.constEnd(); ++it) {
    if (it->enabled) {
      // convert ID to lower case and strip "minecraft:" if exists
      TentityMap::const_iterator info = it->map.find(id.toLower().remove("minecraft:"));
      if (info != it->map.end()) {  // found it
        return info.value();
      }
    }
  }
  return entityDummy;
}

QColor EntityIdentifier::getBrushColor(const QString id) const {
  return getEntityInfo(id).brushColor;
}

QColor EntityIdentifier::getPenColor(const QString id) const {
  return getEntityInfo(id).penColor;
}