void ToyControl::init(char* json)
{
JsonParser<32> parser;
JsonArray root = parser.parse(json);
if (!root.success()) {
HTTP_DEBUG_PRINTLN("JsonParser.parse() failed");
return;
}
else {
if (root.size() == 0) {
return;
}
id = String((char*)root[0]["id"]);
battleId = String((char*)root[0]["battle_id"]);
toyDeviceId = String((char*)root[0]["toy_device_id"]);
type = String((char*)root[0]["type"]);
HTTP_DEBUG_PRINT("id: ");
HTTP_DEBUG_PRINTLN(id);
HTTP_DEBUG_PRINT("battleId: ");
HTTP_DEBUG_PRINTLN(battleId);
HTTP_DEBUG_PRINT("toyDeviceId: ");
HTTP_DEBUG_PRINTLN(toyDeviceId);
HTTP_DEBUG_PRINT("type: ");
HTTP_DEBUG_PRINTLN(type);
}
}
void FeedbackDialog::requestFinished(bool result)
{
ui->sendButton->setEnabled(true);
QString error = tr("Error! %1");
if (!result)
{
msg( error.arg( uploader.errorString() ) );
return;
}
JsonParser parser;
if ( !parser.setJson( uploader.getData() ) )
{
msg( error.arg( parser.getParserError() ) );
return;
}
if ( parser.hasServerResponseError() )
{
msg( error.arg( parser.getServerResponseError() ) );
return;
}
msg( tr("Feedback log successfully uploaded!") );
}
void StoreManageDialog::onVersionsReply(bool result)
{
if (result)
{
log( tr("Versions list received. Parsing...") );
JsonParser parser;
if ( !parser.setJson( fetcher.getData() ) )
{
log( tr("Error: ") + parser.getParserError() );
}
else
{
if ( !parser.hasVersionList() )
{
log( tr("Error: reply not contain version list!") );
}
else
{
QStringList versions = parser.getReleaseVersonList();
ui->versionCombo->addItems(versions);
log( tr("Versions list for clone is ready!") );
ui->versionCombo->setEnabled(true);
ui->actionButton->setEnabled(true);
}
}
}
else
{
log( tr("Version list not received") );
}
}
void Renderer::parseSceneDescription(){
time_t parseBegin;
time(&parseBegin);
LOG_INFO("*************************************");
LOG_INFO("Parsing scene description.");
m_renderEnv = RenderEnvironment();
m_renderEnv.shadingEngine = new ShadingEngine();
m_renderEnv.globals = new AuroraGlobals;
m_renderEnv.stringGlobals = new StringMap;
setDefaultOptions(m_renderEnv.globals);
// open file
JsonParser parser = JsonParser(m_filename, &m_renderEnv);
parser.parseScene(NULL);
m_objects = parser.getObjects();
m_lights = parser.getLights();
LOG_INFO("Done parsing scene description.");
LOG_INFO("*************************************\n");
// Time
time_t parseEnd;
time(&parseEnd);
int totalTime = difftime(parseEnd, parseBegin);
LOG_INFO("Total parsing time: "
<< floor(totalTime/60/60) << " h "
<< floor((totalTime/60) % 60) << " min "
<< totalTime % 60 << " sec.");
}
void UpdateDialog::versionListRequested(bool result)
{
if (!result)
{
error( tr("Latest version does not received.") );
return;
}
JsonParser versionsParser;
if ( !versionsParser.setJson( versionsFetcher.getData() ) )
{
log(versionsParser.getParserError(), true);
error( tr("Inavlid reply.") );
return;
}
if ( !versionsParser.hasLatestReleaseVersion() )
{
error( tr("Reply does not contains 'latest' version.") );
return;
}
clientVersion = versionsParser.getLatestReleaseVersion();
log( tr("Client version received: %1.").arg(clientVersion) );
updateVersionIndex();
}
/*!
Parses the JSON string \a str as a QVariant.
If the parse succeeds, this function returns true and the QVariant can
be accessed using result(). If the parse fails, this function returns
false and the error message can be accessed using errorMessage().
*/
bool JsonReader::parse(const QString &str)
{
JsonLexer lexer(str);
JsonParser parser;
if (!parser.parse(&lexer)) {
m_errorString = parser.errorMessage();
m_result = QVariant();
return false;
}
m_errorString.clear();
m_result = parser.result();
return true;
}
/**
* @brief SocketThread::processMessage
* @param message
*/
void SocketThread::processMessage(QString message)
{
// ANY PROCESS HERE IS DONE IN THE SOCKET THREAD !
JsonParser jsonparser;
QString json = jsonparser.read(message);
QString retMessage;
QStringList list;
char retBuffer[255];
char *retName;
int idx;
std::cout << tr("thread 0x%1 | %2")
.arg(QString::number((intptr_t)QThread::currentThreadId(), 16)).arg(message).toStdString() << std::endl;
QString select = "select SOURCES_PATH from sources where project_id = ";
QString query = select + message;
const char *rawQuery = query.toStdString().c_str();
if(mysql_query(conn,rawQuery )){
printf("query fail\n");
exit(1);
}
printf("query success\n");
res = mysql_store_result(conn);
idx = mysql_num_fields(res) ;
while( (row=mysql_fetch_row(res))!=NULL){
for( int cnt = 0 ; cnt < idx ; ++cnt){
retName = strcpy(retBuffer, row[cnt]);
list.append(row[cnt]);
printf("%s", retName);
sendMessage(retName);
}
printf("---\n") ;
}
// for(int i = 0; list[i]!=NULL ; ++i){
// printf("%s\n", list[i]);
// //str.toStdString().c_str();
// QByteArray byteName = list[i].toLocal8Bit();
// retName = byteName.data();
// //retName = list[i].toStdString().c_str();
// sendMessage(retName);
// }
mysql_close(conn);
}
int main(int ac, char **av) {
PackageManager pkgMan;
JsonParser parser;
std::string cmd, topic, type;
int cpt;
int size = parser.getSize();;
while (parser.parseNextPackage(cmd, topic, type, cpt)) {
std::cout << "launch package:" << cmd << " " << topic << " " << type <<std::endl;
pkgMan.launchPackage(cmd, topic, type);
std::cout << "Package " << cpt << "/" << size << " launched..." << std::endl;
sleep(2);
}
std::cout << std::endl << "<<< MscProject launched >>>" << std::endl << std::endl;
return 0;
}
Configuration::Configuration(std::string json) {
// LOG(INFO) << "Start JSON Parser";
this->attributes = json;
JsonParser jp;
// LOG(INFO) << "Start JSON Parser 2";
std::shared_ptr<AttributeMap> property_map = jp.parse(json);
// LOG(INFO) << "end JSON Parser";
this->camera_attribute = std::static_pointer_cast<CameraAttribute>( (*property_map)["camera"] );
this->image_processor_attribute = std::static_pointer_cast<ImageProcessorAttribute>( (*property_map)["image_processors"] );
// std::cout<<"============== configuration =============="<<std::endl;
// std::cout<<"camera name:"<< this->camera_attribute->getName() <<std::endl;
// std::cout<<"Image Processor name:"<<this->image_processor_attribute->getName()<<std::endl;
// std::cout<<"Image Processor size:"<<this->image_processor_attribute->getImageProcessorAttributeVector().size()<<std::endl;
std::vector< std::shared_ptr<ImageProcessorAttribute> > ipp =
this->image_processor_attribute->getImageProcessorAttributeVector();
// for (std::vector<ImageProcessorAttribute*>::size_type i = 0; i < ipp.size(); ++i){
// std::cout << "processor name: " << ipp[i]->getName() << std::endl;
// }
}
void WebSocketRailsChannel::dispatch(String eventName,
String data) {
if(eventName.equals("websocket_rails.channel_token")) {
JsonParser<16> parser;
char buffer[data.length() + 1];
data.toCharArray(buffer, data.length() + 1);
Parser::JsonObject frame = parser.parse(buffer);
this->token = frame["token"];
}
else {
if (! callbacks.contains(eventName))
return;
LinkedList<EventCompletionBlock> eventCallbacks = callbacks[eventName];
for(int i = 0; i < eventCallbacks.size(); i++){
EventCompletionBlock callback = eventCallbacks.get(i);
callback(data);
}
}
}
int main(int argc, char* argv[])
{
if(argc != 2)
{
std::cout << "Please provide a filename" << std::endl;
}
else
{
JsonParser p;
std::map<std::string, std::string> configFile = p.parse(argv[1]);
std::cout << "file contents" << std::endl;
std::cout << "project url: " << configFile["project url"] << std::endl;
for(std::map<std::string, std::string>::iterator it = configFile.begin(); it != configFile.end(); ++it)
{
std::cout << it->first << " : " << it->second << std::endl;
}
}
return 0;
}
static void testJsonParser()
{
// SETTINGS FILE
JsonParser test = JsonParser("Settings.json");
test.parseFile(FileType::SETTINGS);
Settings settings = test.getSettingsFileContent();
std::cout << "------------- BEGINNING OF TESTING SETTINGS FILE READER -------------" << std::endl << std::endl;
std::cout << "Resolution: " << settings.getResolutionString() << std::endl;
std::cout << "Volume: " << settings.getVolumeString() << std::endl;
std::cout << "Fullscreen: " << settings.getIsFullscreenString() << std::endl;
std::cout << "Fps: " << settings.getFpsString() << std::endl;
//std::cout << "Keys Mapping: " << settings.getKeysMapping() << std::endl;
test.saveSettings(settings, "Settings.json");
std::cout << std::endl << "------------- END OF TESTING SETTINGS FILE READER -------------" << std::endl << std::endl;
// MAP FILE
std::cout << "------------- BEGINNING OF TESTING MAP FILE READER -------------" << std::endl << std::endl;
test.setFilePath("Maps/TestHeatZones.json");
test.parseFile(FileType::MAP);
MapInfos map = test.parseMap();
map.displayMapInfos();
std::cout << std::endl << "------------- END OF TESTING MAP FILE READER -------------" << std::endl;
system("pause");
}
void GameLayer::onEnter()
{
Layer::onEnter();
auto visibleSize = Director::getInstance()->getVisibleSize();
this->m_origin = Director::getInstance()->getVisibleOrigin();
m_pTiledMap = TMXTiledMap::create("TYCHEs_COFEE.tmx");
m_TiledMapSize.setSize(m_pTiledMap->getMapSize().width * m_pTiledMap->getTileSize().width, m_pTiledMap->getMapSize().height * m_pTiledMap->getTileSize().height);
this->addChild(m_pTiledMap);
TMXObjectGroup *objects = m_pTiledMap->getObjectGroup("Objects");
CCASSERT(NULL != objects, "'Objects' object group not found");
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("hero.plist");
auto spawnPoint = objects->getObject("SpawnPoint");
CCASSERT(!spawnPoint.empty(), "SpawnPoint object not found");
Point heroInitPos = m_origin + Point(spawnPoint["x"].asFloat(), spawnPoint["y"].asFloat());
m_pHero = Hero::create();
m_pHero->setScale(0.5f);
m_pHero->setPosition(heroInitPos);
m_pHero->runIdleAction();
m_pHero->setLocalZOrder(visibleSize.height - m_pHero->getPositionY());
m_pHero->setHP(100);
m_pHero->setIsAttacking(false);
m_pHero->setJumpStage(0);
m_pHero->onDeadCallback = CC_CALLBACK_0(GameLayer::onHeroDead, this, m_pHero);
m_pHero->attack = CC_CALLBACK_0(GameLayer::onHeroAttack, this);
m_pHero->stop = CC_CALLBACK_0(GameLayer::onHeroStop, this);
m_pHero->walk = CC_CALLBACK_1(GameLayer::onHeroWalk, this);
m_pHero->jump = CC_CALLBACK_1(GameLayer::onHeroJump, this);
this->addChild(m_pHero);
auto centerOfView = Point(visibleSize.width / 2, visibleSize.height / 2);
this->setPosition(centerOfView - m_pHero->getPosition());
m_pForesight = Foresight::create();
this->addChild(m_pForesight);
JsonParser* parser = JsonParser::createWithFile("Debug.json");
parser->decodeDebugData();
auto list = parser->getList();
for (auto& v : list)
{
ValueMap row = v.asValueMap();
for (auto& pair : row)
{
CCLOG("%s %s", pair.first.c_str(), pair.second.asString().c_str());
if (pair.first.compare("HeroHSpeed") == 0)
{
float s = pair.second.asFloat();
m_pHero->setWalkVelocity(s);
}
else if (pair.first.compare("HeroVSpeed") == 0)
{
m_pHero->setJumpVelocity(pair.second.asFloat());
}
else if (pair.first.compare("BulletPower") == 0)
{
m_pHero->setBullletPower(pair.second.asInt());
}
else if (pair.first.compare("BulletSpeed") == 0)
{
m_pHero->setBulletLaunchVelocity(pair.second.asFloat());
}
else if (pair.first.compare("BulletDisappearTime") == 0)
{
m_pHero->setBulletDisappearTime(pair.second.asFloat());
}
else if (pair.first.compare("BulletAngle") == 0)
{
m_pHero->setBullletAngle(pair.second.asInt());
}
else if (pair.first.compare("BulletInterval") == 0)
{
m_pHero->setBulletInterval(pair.second.asFloat());
}
else if (pair.first.compare("WorldG") == 0)
{
//getScene()->getPhysicsWorld()->setGravity(Vec2(0.f, pair.second.asFloat()));
}
else if (pair.first.compare("ForesightSpeed") == 0)
{
initForesight(pair.second.asFloat());
}
else if (pair.first.compare("AmmoCapacity") == 0)
{
m_pHero->setMaxAmmoCapacity(pair.second.asInt());
m_pHero->setAmmoCapacity(pair.second.asInt());
}
}
}
/*const PhysicsMaterial m(1.f, 0.f, 0.f);
Size boxSize(m_pTiledMap->getMapSize().width * m_pTiledMap->getTileSize().width, m_pTiledMap->getMapSize().height * m_pTiledMap->getTileSize().height);
auto body = PhysicsBody::createEdgeBox(boxSize, m, 3);
body->setTag(0);
body->setCategoryBitmask(0x04);
body->setContactTestBitmask(0x02);
body->setCollisionBitmask(0x03);
auto edgeNode = Node::create();
edgeNode->setPosition(Point(boxSize.width / 2, boxSize.height / 2));
edgeNode->setPhysicsBody(body);
this->addChild(edgeNode);*/
importGroundData(m_pTiledMap);
m_shootTime = m_pHero->getBulletInterval();
auto listener = EventListenerCustom::create("bullet_disappear", [this](EventCustom* event) {
Bullet* bullet = static_cast<Bullet *>(event->getUserData());
if (bullet)
this->removeChild(bullet);
});
_eventDispatcher->addEventListenerWithFixedPriority(listener, 1);
m_vecEventListener.pushBack(listener);
/*auto contactListener = EventListenerPhysicsContact::create();
contactListener->onContactBegin = [this](PhysicsContact& contact)->bool
{
if (contact.getShapeA()->getBody()->getCategoryBitmask() == PC_Hero && contact.getShapeB()->getBody()->getCategoryBitmask() == PC_Ground)
{
Point posA = contact.getShapeA()->getBody()->getPosition();
Point posB = contact.getShapeB()->getBody()->getPosition();
if (posA.y >= posB.y)
{
Hero* hero = static_cast<Hero *>(contact.getShapeA()->getBody()->getNode());
if (hero->getCurrActionState() == ACTION_STATE_MOVE && hero->isInMoveAction(MOVE_STATE_DOWN))
{
if (hero->isInMoveAction(MOVE_STATE_WALK))
{
hero->stopMoveAction(MOVE_STATE_DOWN, true);
Vec2 v = hero->getPhysicsBody()->getVelocity();
hero->walk(v.x);
CCLOG("Hero Walk");
}
else
{
CCLOG("Hero Stop");
hero->stop();
}
hero->setJumpStage(0);
}
return true;
}
else
{
return false;
}
}
else if (contact.getShapeA()->getBody()->getCategoryBitmask() == PC_Ground && contact.getShapeB()->getBody()->getCategoryBitmask() == PC_Hero)
{
Point posA = contact.getShapeA()->getBody()->getPosition();
Point posB = contact.getShapeB()->getBody()->getPosition();
if (posA.y <= posB.y)
{
Hero* hero = static_cast<Hero *>(contact.getShapeB()->getBody()->getNode());
if (hero->getCurrActionState() == ACTION_STATE_MOVE && hero->isInMoveAction(MOVE_STATE_DOWN))
{
if (hero->isInMoveAction(MOVE_STATE_WALK))
{
hero->stopMoveAction(MOVE_STATE_DOWN, true);
Vec2 v = hero->getPhysicsBody()->getVelocity();
hero->walk(v.x);
CCLOG("Hero Walk");
}
else
{
CCLOG("Hero Stop");
hero->stop();
}
hero->setJumpStage(0);
}
return true;
}
else
{
return false;
}
}
else if(contact.getShapeA()->getBody()->getCategoryBitmask() == PC_Bullet && contact.getShapeB()->getBody()->getCategoryBitmask() == PC_Ground)
{
Bullet* bullet = static_cast<Bullet *>(contact.getShapeA()->getBody()->getNode());
if(bullet)
{
bullet->setIsActive(false);
this->removeChild(bullet);
}
}
else if(contact.getShapeA()->getBody()->getCategoryBitmask() == PC_Ground && contact.getShapeB()->getBody()->getCategoryBitmask() == PC_Bullet)
{
Bullet* bullet = static_cast<Bullet *>(contact.getShapeB()->getBody()->getNode());
if(bullet)
{
bullet->setIsActive(false);
this->removeChild(bullet);
}
}
return true;
};
_eventDispatcher->addEventListenerWithSceneGraphPriority(contactListener, this);
m_vecEventListener.pushBack(contactListener);*/
//this->getScene()->getPhysicsWorld()->setAutoStep(false);
this->scheduleUpdate();
}
Request* RequestFactory::createRequest(const websocketpp::server::handler::connection_ptr& con,const std::string& source){
//parsing json
JsonParser* parser = new JsonParser(source);
if(parser->getCurrentValue()){
if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(MESSAGE)) == 0){
if(parser->nextValue()){
return new RequestMessage(parser,con,this->server);
}
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(SEND_SELF_DATA)) == 0){
if(parser->nextValue()){
return new RequestSendSelfData(parser,con,this->server);
}
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(LAUNCH_GAME)) == 0){
if(parser->nextValue()){
return new RequestLaunchGame(parser,con,this->server);
}
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(REFRESH_OUT_GAME_DATA)) == 0){
delete parser;
return new RequestRefreshOutGameData(con,this->server);
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(CREATE_GAME)) == 0){
delete parser;
return new RequestCreateGame(con,this->server);
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(JOIN_GAME)) == 0){
if(parser->nextValue()){
return new RequestJoinGame(parser,con,this->server);
}
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(SELECT_SERVER_MAP)) == 0){
return new RequestSelectMap(parser,con,this->server);
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(CHOOSE_COLOR)) == 0){
return new RequestChooseColor(parser,con,this->server);
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(MOVE)) == 0){
if(parser->nextValue()){
return new RequestMove(parser,con,this->server);
}
}
else if(std::string((parser->getCurrentValue()->string_value)).compare(stringify(DROP_BOMB)) == 0){
if(parser->nextValue()){
return new RequestDropBomb(parser,con,this->server);
}
}
}
return new Request(con);
}
void test1()
{
JsonParser jp;
jp.newTrue("true");
jp.newFalse("false");
Json* arr = jp.newArray("arr");
Json* obj = jp.newObject(arr);
jp.newString("hello", "yangyoufa", obj);
jp.newNumber("a", 100, obj);
Json* obj1 = jp.newObject(arr);
jp.newString("hello", "yy", obj1);
jp.newNull("", obj1);
printf("%s\n", jp.toString());
u32_t v;
jp.getNumber(jp.find("a", obj), v);
printf("%d\n", v);
printf("%s\n", jp.getString(jp.find("hello", obj)));
}
