#include "JsonExpression.h" #include "Dimension.h" #include "DimensionGenerator.h" #include "Game.h" JExpressionMemory::JExpressionMemory() : ReferenceCounter(), currentChunk(0) {} JExpressionMemory::~JExpressionMemory() { if (currentChunk) currentChunk->release(); } void JExpressionMemory::lock() { cs.lock(); } void JExpressionMemory::unlock() { cs.unlock(); } float JExpressionMemory::getNoise( Framework::Text name, float x, float y, float z) const { Noise* currentNoise = noises.z(name, name.getLength()); if (currentNoise) return (float)currentNoise->getNoise((double)x, (double)y, (double)z); return 0.f; } void JExpressionMemory::setNoise(Framework::Text name, Noise* noise) { noises.set(name, name.getLength(), noise); } void JExpressionMemory::setCurrentChunk(Chunk* chunk) { if (currentChunk) currentChunk->release(); currentChunk = chunk; } float JExpressionMemory::getFloatVariable(Framework::Text name) const { return floatVariables.get(name, name.getLength()); } void JExpressionMemory::setFloatVariable(Framework::Text name, float value) { floatVariables.set(name, name.getLength(), value); } bool JExpressionMemory::getBoolVariable(Framework::Text name) const { return boolVariables.get(name, name.getLength()); } void JExpressionMemory::setBoolVariable(Framework::Text name, bool value) { return boolVariables.set(name, name.getLength(), value); } Chunk* JExpressionMemory::zCurrentChunk() { return currentChunk; } JFloatExpression::JFloatExpression() : ReferenceCounter() {} JBoolExpression::JBoolExpression() : ReferenceCounter() {} JVariableFloatExpression::JVariableFloatExpression() : JFloatExpression() {} float JVariableFloatExpression::getValue(JExpressionMemory* zMemory) { return zMemory->getFloatVariable(name); } void JVariableFloatExpression::setName(Framework::Text name) { this->name = name; } Framework::Text JVariableFloatExpression::getName() const { return name; } JVariableFloatExpressionFactory::JVariableFloatExpressionFactory() : SubTypeFactory() {} JVariableFloatExpression* JVariableFloatExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JVariableFloatExpression(); } void JVariableFloatExpressionFactory::fromJson( JVariableFloatExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setName(zJson->zValue("name")->asString()->getString()); } void JVariableFloatExpressionFactory::toJson(JVariableFloatExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "name", new Framework::JSON::JSONString(zObject->getName())); } JSONObjectValidationBuilder* JVariableFloatExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("name")->finishString(); } Framework::Text JVariableFloatExpressionFactory::getTypeToken() const { return "variable"; } JVariableBoolExpression::JVariableBoolExpression() : JBoolExpression() {} bool JVariableBoolExpression::getValue(JExpressionMemory* zMemory) { return zMemory->getBoolVariable(name); } void JVariableBoolExpression::setName(Framework::Text name) { this->name = name; } Framework::Text JVariableBoolExpression::getName() const { return name; } JVariableBoolExpressionFactory::JVariableBoolExpressionFactory() : SubTypeFactory() {} JVariableBoolExpression* JVariableBoolExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JVariableBoolExpression(); } void JVariableBoolExpressionFactory::fromJson( JVariableBoolExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setName(zJson->zValue("name")->asString()->getString()); } void JVariableBoolExpressionFactory::toJson(JVariableBoolExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "name", new Framework::JSON::JSONString(zObject->getName())); } JSONObjectValidationBuilder* JVariableBoolExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("name")->finishString(); } Framework::Text JVariableBoolExpressionFactory::getTypeToken() const { return "variable"; } JConstantFloatExpression::JConstantFloatExpression() : JFloatExpression(), value(0) {} float JConstantFloatExpression::getValue(JExpressionMemory* zMemory) { return value; } void JConstantFloatExpression::setValue(float value) { this->value = value; } float JConstantFloatExpression::getValue() const { return value; } JConstantFloatExpressionFactory::JConstantFloatExpressionFactory() : SubTypeFactory() {} JConstantFloatExpression* JConstantFloatExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JConstantFloatExpression(); } void JConstantFloatExpressionFactory::fromJson( JConstantFloatExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setValue((float)zJson->zValue("value")->asNumber()->getNumber()); } void JConstantFloatExpressionFactory::toJson(JConstantFloatExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "value", new Framework::JSON::JSONNumber(zObject->getValue())); } JSONObjectValidationBuilder* JConstantFloatExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredNumber("value")->finishNumber(); } Framework::Text JConstantFloatExpressionFactory::getTypeToken() const { return "constant"; } JConstantBoolExpression::JConstantBoolExpression() : JBoolExpression() {} bool JConstantBoolExpression::getValue(JExpressionMemory* zMemory) { return value; } void JConstantBoolExpression::setValue(bool value) { this->value = value; } bool JConstantBoolExpression::getValue() const { return value; } JConstantBoolExpressionFactory::JConstantBoolExpressionFactory() : SubTypeFactory() {} JConstantBoolExpression* JConstantBoolExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JConstantBoolExpression(); } void JConstantBoolExpressionFactory::fromJson( JConstantBoolExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setValue(zJson->zValue("value")->asBool()->getBool()); } void JConstantBoolExpressionFactory::toJson(JConstantBoolExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "value", new Framework::JSON::JSONBool(zObject->getValue())); } JSONObjectValidationBuilder* JConstantBoolExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredBool("value")->finishBool(); } Framework::Text JConstantBoolExpressionFactory::getTypeToken() const { return "constant"; } JNoiseFloatExpression::JNoiseFloatExpression() : JFloatExpression(), x(0), y(0), z(0) {} JNoiseFloatExpression::~JNoiseFloatExpression() { if (x) x->release(); if (y) y->release(); if (z) z->release(); } float JNoiseFloatExpression::getValue(JExpressionMemory* zMemory) { return zMemory->getNoise( name, x->getValue(zMemory), y->getValue(zMemory), z->getValue(zMemory)); } void JNoiseFloatExpression::setName(Framework::Text name) { this->name = name; } Framework::Text JNoiseFloatExpression::getName() const { return name; } void JNoiseFloatExpression::setX(JFloatExpression* x) { if (this->x) this->x->release(); this->x = x; } JFloatExpression* JNoiseFloatExpression::zX() const { return x; } void JNoiseFloatExpression::setY(JFloatExpression* y) { if (this->y) this->y->release(); this->y = y; } JFloatExpression* JNoiseFloatExpression::zY() const { return y; } void JNoiseFloatExpression::setZ(JFloatExpression* z) { if (this->z) this->z->release(); this->z = z; } JFloatExpression* JNoiseFloatExpression::zZ() const { return z; } JNoiseFloatExpressionFactory::JNoiseFloatExpressionFactory() : SubTypeFactory() {} JNoiseFloatExpression* JNoiseFloatExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JNoiseFloatExpression(); } void JNoiseFloatExpressionFactory::fromJson( JNoiseFloatExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setName(zJson->zValue("name")->asString()->getString()); zResult->setX(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("x"))); zResult->setY(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("y"))); zResult->setZ(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("z"))); } void JNoiseFloatExpressionFactory::toJson( JNoiseFloatExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "name", new Framework::JSON::JSONString(zObject->getName())); zResult->addValue( "x", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zX())); zResult->addValue( "y", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zY())); zResult->addValue( "z", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zZ())); } JSONObjectValidationBuilder* JNoiseFloatExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("name") ->finishString() ->withRequiredAttribute("x", Game::INSTANCE->zTypeRegistry()->getValidator()) ->withRequiredAttribute("y", Game::INSTANCE->zTypeRegistry()->getValidator()) ->withRequiredAttribute("z", Game::INSTANCE->zTypeRegistry()->getValidator()); } Framework::Text JNoiseFloatExpressionFactory::getTypeToken() const { return "noise"; } JOperatorFloatExpression::JOperatorFloatExpression() : JFloatExpression(), accumulator([](float a, float b) { return 0.f; }) {} float JOperatorFloatExpression::getValue(JExpressionMemory* zMemory) { bool first = 1; float val = 0.f; for (JFloatExpression* expression : values) { if (first) { first = 0; val = expression->getValue(zMemory); } else { val = accumulator(val, expression->getValue(zMemory)); } } return val; } void JOperatorFloatExpression::setOperator( Framework::Text op, std::function accumulator) { this->op = op; this->accumulator = accumulator; } Framework::Text JOperatorFloatExpression::getOperator() { return op; } void JOperatorFloatExpression::addValue(JFloatExpression* value) { values.add(value); } const Framework::RCArray& JOperatorFloatExpression::getValues() const { return values; } JOperatorFloatExpressionFactory::JOperatorFloatExpressionFactory() : SubTypeFactory() {} JOperatorFloatExpression* JOperatorFloatExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JOperatorFloatExpression(); } void JOperatorFloatExpressionFactory::fromJson( JOperatorFloatExpression* zResult, Framework::JSON::JSONObject* zJson) const { Framework::Text op = zJson->zValue("operator")->asString()->getString(); if (op.istGleich("+")) { zResult->setOperator("+", [](float a, float b) { return a + b; }); } else if (op.istGleich("-")) { zResult->setOperator("-", [](float a, float b) { return a - b; }); } else if (op.istGleich("*")) { zResult->setOperator("*", [](float a, float b) { return a * b; }); } else if (op.istGleich("/")) { zResult->setOperator("/", [](float a, float b) { return a / b; }); } for (Framework::JSON::JSONValue* value : *zJson->zValue("values")->asArray()) { zResult->addValue( Game::INSTANCE->zTypeRegistry()->fromJson(value)); } } void JOperatorFloatExpressionFactory::toJson(JOperatorFloatExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "operator", new Framework::JSON::JSONString(zObject->getOperator())); Framework::JSON::JSONArray* values = new Framework::JSON::JSONArray(); for (JFloatExpression* expression : zObject->getValues()) { values->addValue( Game::INSTANCE->zTypeRegistry()->toJson( expression)); } zResult->addValue("values", values); } JSONObjectValidationBuilder* JOperatorFloatExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("operator") ->whichIsOneOf({"+", "-", "*", "/"}) ->finishString() ->withRequiredArray("values") ->addAcceptedTypeInArray( Game::INSTANCE->zTypeRegistry()->getValidator()) ->finishArray(); } Framework::Text JOperatorFloatExpressionFactory::getTypeToken() const { return "operator"; } JBoolOperatorBoolExpression::JBoolOperatorBoolExpression() : JBoolExpression() {} bool JBoolOperatorBoolExpression::getValue(JExpressionMemory* zMemory) { bool first = 1; bool val = 0; for (JBoolExpression* expression : values) { if (first) { first = 0; val = expression->getValue(zMemory); } else { val = accumulator(val, expression->getValue(zMemory)); } } return val; } void JBoolOperatorBoolExpression::setOperator( Framework::Text op, std::function accumulator) { this->op = op; this->accumulator = accumulator; } Framework::Text JBoolOperatorBoolExpression::getOperator() { return op; } void JBoolOperatorBoolExpression::addValue(JBoolExpression* value) { values.add(value); } const Framework::RCArray& JBoolOperatorBoolExpression::getValues() const { return values; } JBoolOperatorBoolExpressionFactory::JBoolOperatorBoolExpressionFactory() : SubTypeFactory() {} JBoolOperatorBoolExpression* JBoolOperatorBoolExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JBoolOperatorBoolExpression(); } void JBoolOperatorBoolExpressionFactory::fromJson( JBoolOperatorBoolExpression* zResult, Framework::JSON::JSONObject* zJson) const { for (Framework::JSON::JSONValue* value : *zJson->zValue("values")->asArray()) { zResult->addValue( Game::INSTANCE->zTypeRegistry()->fromJson(value)); } Framework::Text op = zJson->zValue("operator")->asString()->getString(); if (op.istGleich("&&")) { zResult->setOperator("&&", [](bool a, bool b) { return a && b; }); } else if (op.istGleich("||")) { zResult->setOperator("||", [](bool a, bool b) { return a || b; }); } } void JBoolOperatorBoolExpressionFactory::toJson( JBoolOperatorBoolExpression* zObject, Framework::JSON::JSONObject* zResult) const { Framework::JSON::JSONArray* values = new Framework::JSON::JSONArray(); for (JBoolExpression* expression : zObject->getValues()) { values->addValue( Game::INSTANCE->zTypeRegistry()->toJson( expression)); } zResult->addValue("values", values); zResult->addValue( "operator", new Framework::JSON::JSONString(zObject->getOperator())); } JSONObjectValidationBuilder* JBoolOperatorBoolExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("operator") ->whichIsOneOf({"&&", "||"}) ->finishString() ->withRequiredArray("values") ->addAcceptedTypeInArray( Game::INSTANCE->zTypeRegistry()->getValidator()) ->finishArray(); } Framework::Text JBoolOperatorBoolExpressionFactory::getTypeToken() const { return "operator"; } JFloatOperatorBoolExpression::JFloatOperatorBoolExpression() : JBoolExpression() {} bool JFloatOperatorBoolExpression::getValue(JExpressionMemory* zMemory) { bool first = 1; bool val = 1; float last = 0.f; for (JFloatExpression* expression : values) { float current = expression->getValue(zMemory); if (!first) val &= accumulator(last, current); first = 0; last = current; } return val; } void JFloatOperatorBoolExpression::setOperator( Framework::Text op, std::function accumulator) { this->op = op; this->accumulator = accumulator; } Framework::Text JFloatOperatorBoolExpression::getOperator() { return op; } void JFloatOperatorBoolExpression::addValue(JFloatExpression* value) { values.add(value); } const Framework::RCArray& JFloatOperatorBoolExpression::getValues() const { return values; } JFloatOperatorBoolExpressionFactory::JFloatOperatorBoolExpressionFactory() : SubTypeFactory() {} JFloatOperatorBoolExpression* JFloatOperatorBoolExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JFloatOperatorBoolExpression(); } void JFloatOperatorBoolExpressionFactory::fromJson( JFloatOperatorBoolExpression* zResult, Framework::JSON::JSONObject* zJson) const { Framework::Text op = zJson->zValue("operator")->asString()->getString(); if (op.istGleich(">")) { zResult->setOperator( ">", [](float a, float b) { return a > b; }); } else if (op.istGleich("<")) { zResult->setOperator( "<", [](float a, float b) { return a < b; }); } else if (op.istGleich(">=")) { zResult->setOperator( ">=", [](float a, float b) { return a >= b; }); } else if (op.istGleich("<=")) { zResult->setOperator( "<=", [](float a, float b) { return a <= b; }); } else if (op.istGleich("==")) { zResult->setOperator( "==", [](float a, float b) { return a == b; }); } else if (op.istGleich("!=")) { zResult->setOperator( "!=", [](float a, float b) { return a != b; }); } else if (op.istGleich(">i")) { zResult->setOperator( ">i", [](float a, float b) { return (int)a > (int)b; }); } else if (op.istGleich("setOperator( "=i")) { zResult->setOperator( ">=i", [](float a, float b) { return (int)a >= (int)b; }); } else if (op.istGleich("<=i")) { zResult->setOperator( "<=i", [](float a, float b) { return (int)a <= (int)b; }); } else if (op.istGleich("==i")) { zResult->setOperator( "==i", [](float a, float b) { return (int)a == (int)b; }); } else if (op.istGleich("!=i")) { zResult->setOperator( "!=i", [](float a, float b) { return (int)a != (int)b; }); } for (Framework::JSON::JSONValue* value : *zJson->zValue("values")->asArray()) { zResult->addValue( Game::INSTANCE->zTypeRegistry()->fromJson(value)); } } void JFloatOperatorBoolExpressionFactory::toJson( JFloatOperatorBoolExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue( "operator", new Framework::JSON::JSONString(zObject->getOperator())); Framework::JSON::JSONArray* values = new Framework::JSON::JSONArray(); for (JFloatExpression* expression : zObject->getValues()) { values->addValue( Game::INSTANCE->zTypeRegistry()->toJson( expression)); } zResult->addValue("values", values); } JSONObjectValidationBuilder* JFloatOperatorBoolExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { return builder->withRequiredString("operator") ->whichIsOneOf({">", "<", ">=", "<=", "==", "!=", "i", ">=i", "<=i", "==i", "!=i"}) ->finishString() ->withRequiredArray("values") ->addAcceptedTypeInArray( Game::INSTANCE->zTypeRegistry()->getValidator()) ->finishArray(); } Framework::Text JFloatOperatorBoolExpressionFactory::getTypeToken() const { return "comparsion"; } JBlockTypeBoolExpression::JBlockTypeBoolExpression() : JBoolExpression(), typeId(0), x(0), y(0), z(0) {} JBlockTypeBoolExpression ::~JBlockTypeBoolExpression() { if (x) x->release(); if (y) y->release(); if (z) z->release(); } bool JBlockTypeBoolExpression::getValue(JExpressionMemory* zMemory) { int x = (int)(round(this->x->getValue(zMemory))); int y = (int)(round(this->y->getValue(zMemory))); int z = (int)(round(this->z->getValue(zMemory))); if (z < 0 || z >= WORLD_HEIGHT || !zMemory->zCurrentChunk() || Game::getChunkCenter(x, y) != zMemory->zCurrentChunk()->getCenter()) { return 0; } return zMemory->zCurrentChunk()->getBlockTypeAt( Dimension::chunkCoordinates({x, y, z})) == typeId; } void JBlockTypeBoolExpression::setTypeId(int typeId) { this->typeId = typeId; } int JBlockTypeBoolExpression::getTypeId() const { return typeId; } void JBlockTypeBoolExpression::setX(JFloatExpression* x) { if (this->x) this->x->release(); this->x = x; } JFloatExpression* JBlockTypeBoolExpression::zX() const { return x; } void JBlockTypeBoolExpression::setY(JFloatExpression* y) { if (this->y) this->y->release(); this->y = y; } JFloatExpression* JBlockTypeBoolExpression::zY() const { return y; } void JBlockTypeBoolExpression::setZ(JFloatExpression* z) { if (this->z) this->z->release(); this->z = z; } JFloatExpression* JBlockTypeBoolExpression::zZ() const { return z; } JBlockTypeBoolExpressionFactory::JBlockTypeBoolExpressionFactory() : SubTypeFactory() {} JBlockTypeBoolExpression* JBlockTypeBoolExpressionFactory::createValue( Framework::JSON::JSONObject* zJson) const { return new JBlockTypeBoolExpression(); } void JBlockTypeBoolExpressionFactory::fromJson( JBlockTypeBoolExpression* zResult, Framework::JSON::JSONObject* zJson) const { zResult->setTypeId(Game::INSTANCE->getBlockTypeId( zJson->zValue("blockType")->asString()->getString())); zResult->setX(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("x"))); zResult->setY(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("y"))); zResult->setZ(Game::INSTANCE->zTypeRegistry()->fromJson( zJson->zValue("z"))); } void JBlockTypeBoolExpressionFactory::toJson(JBlockTypeBoolExpression* zObject, Framework::JSON::JSONObject* zResult) const { zResult->addValue("blockType", new Framework::JSON::JSONString( Game::INSTANCE->zBlockType(zObject->getTypeId())->getName())); zResult->addValue( "x", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zX())); zResult->addValue( "y", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zY())); zResult->addValue( "z", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zZ())); } JSONObjectValidationBuilder* JBlockTypeBoolExpressionFactory::addToValidator( JSONObjectValidationBuilder* builder) const { Framework::RCArray blockTypeNames; for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++) { if (Game::INSTANCE->zBlockType(i)) { blockTypeNames.add( new Framework::Text(Game::INSTANCE->zBlockType(i)->getName())); } } return builder->withRequiredString("blockType") ->whichIsOneOf(blockTypeNames) ->finishString() ->withRequiredAttribute("x", Game::INSTANCE->zTypeRegistry()->getValidator()) ->withRequiredAttribute("y", Game::INSTANCE->zTypeRegistry()->getValidator()) ->withRequiredAttribute("z", Game::INSTANCE->zTypeRegistry()->getValidator()); } Framework::Text JBlockTypeBoolExpressionFactory::getTypeToken() const { return "blockType"; }