float TableDefinition::getValue(float index)
{
if (!_parsed) parseDefinition();
// Don't bother if we don't have any values to look up
if (_values.empty())
{
return 0.0f;
}
if (_values.size() == 1)
{
return _values[0];
}
if (_clamp)
{
if (index > 1.0f)
{
index = 1.0f - 1.0f / _values.size();
}
else if (index < 0.0f)
{
index = 0.0f;
}
// Map the index to the [0..N-1] interval
index *= _values.size() - 1;
}
else
{
// Only take the fractional part of the index
index = std::fmod(index, 1.0f);
// Map the index to the [0..N] interval
index *= _values.size();
}
// If snap is active, round the values to the nearest integer
if (_snap)
{
index = std::floor(index + 0.5f);
return _values[static_cast<std::size_t>(index) % _values.size()];
}
else
{
// No snapping, pick the interpolation values
std::size_t leftIdx = static_cast<std::size_t>(std::floor(index)) % _values.size();
std::size_t rightIdx = (leftIdx + 1) % _values.size();
float fraction = index - leftIdx;
return (1-fraction)*_values[leftIdx] + fraction*_values[rightIdx];
}
}
int FlatteningConverter::addDefinitions(JSONArray *defs, int pack) {
// if (pack == -1) {
// pack = packs.length();
// packs.append(QList<BlockInfo*>());
// }
int len = defs->length();
for (int i = 0; i < len; i++)
parseDefinition(dynamic_cast<JSONObject *>(defs->at(i)), NULL, pack);
return pack;
}
int BlockIdentifier::addDefinitions(JSONArray *defs, int pack) {
if (pack == -1) {
pack = packs.length();
packs.append(QList<BlockInfo*>());
}
int len = defs->length();
for (int i = 0; i < len; i++)
parseDefinition(dynamic_cast<JSONObject *>(defs->at(i)), NULL, pack);
// clear cache
clearCache();
return pack;
}
std::unique_ptr<ParsedFile> parseFileSyntax(const FileForParsing& ffp) {
auto file = std::unique_ptr<ParsedFile>(new ParsedFile());
Lexer lexer(ffp);
while(lexer.hasCurrentToken()) {
if(lexer.currType()==STATEMENT_END) {
lexer.advance(); //Eat ';'
continue; //Extra semicolons are ok
}
bool pub = lexer.currType()==PUB;
if(pub)
lexer.advance();
unique_ptr<Definition> definition = parseDefinition(lexer, pub);
if(definition) { //A nice definition was returned, and has eaten it's own semicolon
definition->printSignature();
file->m_definitions.push_back(std::move(definition));
}
else if(lexer.hasCurrentToken()) //Error occurred, but already printed
skipUntilNewDefinition(lexer);
}
terminateIfErrors();
return file;
}
void CMakeTool::parseFunctionDetailsOutput(const QString &output)
{
QSet<QString> functionSet;
functionSet.fromList(m_functions);
bool expectDefinition = false;
QString currentDefinition;
const QStringList lines = output.split('\n');
for (int i = 0; i < lines.count(); ++i) {
const QString line = lines.at(i);
if (line == "::") {
expectDefinition = true;
continue;
}
if (expectDefinition) {
if (!line.startsWith(' ') && !line.isEmpty()) {
expectDefinition = false;
QStringList words = parseDefinition(currentDefinition);
if (!words.isEmpty()) {
const QString command = words.takeFirst();
if (functionSet.contains(command)) {
QStringList tmp = words + m_functionArgs[command];
Utils::sort(tmp);
m_functionArgs[command] = Utils::filteredUnique(tmp);
}
}
if (!words.isEmpty() && functionSet.contains(words.at(0)))
m_functionArgs[words.at(0)];
currentDefinition.clear();
} else {
currentDefinition.append(line.trimmed() + ' ');
}
}
}
}
void FlatteningConverter::parseDefinition(
JSONObject *b,
int *parentID,
int pack) {
// get the ancient block ID
int bid, data(0);
if (parentID == NULL) {
bid = b->at("id")->asNumber();
} else {
bid = *parentID;
data = b->at("data")->asNumber();
bid |= data << 8;
}
// try to translate old block name into new flatname
QString flatname;
if (b->has("name")) {
flatname = "minecraft:" + b->at("name")->asString().toLower().replace(" ", "_");
} else if (parentID != NULL) {
flatname = palette[*parentID].name;
} else {
flatname = "Unknown";
}
// or use provided flatname instead
if (b->has("flatname"))
flatname = b->at("flatname")->asString();
palette[bid].name = flatname;
palette[bid].hid = qHash(palette[bid].name);
if ((parentID == NULL) && (data == 0)) {
// spread main block type for data == 0
for (int d=1; d<16; d++) {
int sid = bid | (d<<8);
palette[sid].name = flatname;
palette[sid].hid = palette[bid].hid;
}
}
// packs[pack].append(block);
// get optional mask value (or guess default)
int mask = 0;
if (b->has("mask")) {
mask = b->at("mask")->asNumber();
} else if (b->has("variants")) {
mask = 0x0f;
}
// recursive parsing of variants (with data)
if (b->has("variants")) {
JSONArray *variants = dynamic_cast<JSONArray *>(b->at("variants"));
int vlen = variants->length();
for (int j = 0; j < vlen; j++) {
parseDefinition(dynamic_cast<JSONObject *>(variants->at(j)), &bid, pack);
}
// spread variants in masked bid
for (int j = vlen; j < 16; j++) {
int id = bid | (j << 8);
int mid = bid | ((j & mask) << 8);
palette[id].name = palette[mid].name;
palette[id].hid = palette[mid].hid;
}
}
}
void BlockIdentifier::parseDefinition(JSONObject *b, BlockInfo *parent,
int pack) {
int id;
if (parent == NULL) {
id = b->at("id")->asNumber();
} else {
id = parent->id;
int data = b->at("data")->asNumber();
id |= data << 12;
}
BlockInfo *block = new BlockInfo();
block->id = id;
if (b->has("name"))
block->setName(b->at("name")->asString());
else if (parent != NULL)
block->setName(parent->getName());
else
block->setName("Unknown");
block->enabled = true;
if (b->has("transparent")) {
block->transparent = b->at("transparent")->asBool();
block->rendernormal = false; // for most cases except the following
if (b->has("rendercube"))
block->rendernormal = b->at("rendercube")->asBool();
block->spawninside = false; // for most cases except the following
if (b->has("spawninside"))
block->spawninside = b->at("spawninside")->asBool();
} else if (parent != NULL) {
block->transparent = parent->transparent;
block->rendernormal = parent->rendernormal;
block->spawninside = parent->spawninside;
} else {
block->transparent = false;
block->rendernormal = true;
block->spawninside = false;
}
if (b->has("liquid"))
block->liquid = b->at("liquid")->asBool();
else if (parent != NULL)
block->liquid = parent->liquid;
else
block->liquid = false;
if (b->has("canProvidePower"))
block->providepower = b->at("canProvidePower")->asBool();
else if (parent != NULL)
block->providepower = parent->providepower;
else
block->providepower = false;
if (b->has("alpha"))
block->alpha = b->at("alpha")->asNumber();
else if (parent != NULL)
block->alpha = parent->alpha;
else
block->alpha = 1.0;
QColor blockcolor;
if (b->has("color")) {
QString colorname = b->at("color")->asString();
if (colorname.length() == 6) {
// check if this is an old color definition with missing '#'
bool ok;
colorname.toInt(&ok,16);
if (ok)
colorname.push_front('#');
}
blockcolor.setNamedColor(colorname);
assert(blockcolor.isValid());
} else if (parent != NULL) {
// copy brightest color from parent
blockcolor = parent->colors[15];
} else {
// use hashed by name instead
quint32 hue = qHash(block->getName());
blockcolor.setHsv(hue % 360, 255, 255);
}
// pre-calculate light spectrum
for (int i = 0; i < 16; i++) {
// calculate light attenuation similar to Minecraft
// except base 90% here, were Minecraft is using 80% per level
double light_factor = pow(0.90,15-i);
block->colors[i].setRgb(light_factor*blockcolor.red(),
light_factor*blockcolor.green(),
light_factor*blockcolor.blue(),
255*block->alpha );
}
if (b->has("mask"))
block->mask = b->at("mask")->asNumber();
else if (b->has("variants"))
block->mask = 0x0f;
else
block->mask = 0x00;
if (b->has("variants")) {
JSONArray *variants = dynamic_cast<JSONArray *>(b->at("variants"));
int vlen = variants->length();
for (int j = 0; j < vlen; j++)
parseDefinition(dynamic_cast<JSONObject *>(variants->at(j)), block, pack);
}
blocks[id].append(block);
packs[pack].append(block);
}
const std::string& SoundShader::getDisplayFolder() const
{
if (!_contents) parseDefinition();
return _contents->displayFolder;
}
SoundFileList SoundShader::getSoundFileList() const
{
if (!_contents) parseDefinition();
return _contents->soundFiles;
}
SoundRadii SoundShader::getRadii() const
{
if (!_contents) parseDefinition();
return _contents->soundRadii;
}
int main(int argc, const char *argv[])
{
Definition definition;
Definition definitions[MAX_DEFINITIONS];
uint definitionCount;
int z;
struct stat statBuffer;
uint64 size;
const char *inputFileName;
FILE *inputHandle;
uint deleteCount;
byte data;
uint64 n;
/* parse command line */
CmdOption_init(COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS));
if (!CmdOption_parse(argv,&argc,
COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS),
CMD_PRIORITY_ANY,
stderr,NULL
)
)
{
return 1;
}
if (versionFlag)
{
printf("Destroyer version %s\n",VERSION);
return 0;
}
if (helpFlag)
{
printUsage(argv[0]);
return 0;
}
if (argc <= 1)
{
fprintf(stderr,"ERROR: No input file given!\n");
exit(1);
}
inputFileName = argv[1];
/* get file size */
if (stat(inputFileName,&statBuffer) != 0)
{
fprintf(stderr,"ERROR: Cannot detect size of file '%s' (error: %s)\n",
inputFileName,
strerror(errno)
);
exit(1);
}
size = statBuffer.st_size;
/* parse definitions */
initRandom(size);
definitionCount = 0;
for (z = 2; z < argc; z++)
{
if (!parseDefinition(argv[z],&definition,size))
{
exit(1);
}
if (definitionCount >= MAX_DEFINITIONS)
{
fprintf(stderr,"ERROR: to many definitions! Max. %d possible.\n",MAX_DEFINITIONS);
}
definitions[definitionCount] = definition;
definitionCount++;
}
/* open input file */
inputHandle = fopen(inputFileName,"r");
if (inputHandle == NULL)
{
fprintf(stderr,"ERROR: Cannot open file '%s' (error: %s)\n",
inputFileName,
strerror(errno)
);
exit(1);
}
/* destroy and write to stdout */
deleteCount = 0;
for (n = 0; n < size; n++)
{
/* read byte */
data = fgetc(inputHandle);
if (deleteCount == 0)
{
/* find matching definition */
z = 0;
while ((z < definitionCount) && (n != definitions[z].position))
{
z++;
}
/* output byte */
if (z < definitionCount)
{
switch (definitions[z].type)
{
case DEFINITION_TYPE_MODIFY:
case DEFINITION_TYPE_RANDOMIZE:
fwrite(String_cString(definitions[z].value),1,String_length(definitions[z].value),stdout);
deleteCount = String_length(definitions[z].value)-1;
break;
case DEFINITION_TYPE_INSERT:
fwrite(String_cString(definitions[z].value),1,String_length(definitions[z].value),stdout);
fputc(data,stdout);
break;
case DEFINITION_TYPE_DELETE:
deleteCount = definitions[z].length-1;
break;
}
}
else
{
fputc(data,stdout);
}
}
else
{
deleteCount--;
}
}
/* close files */
fclose(inputHandle);
/* free resources */
CmdOption_done(COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS));
return 0;
}
