Exemple #1
0
	// -----------------------------------------------
	// load JSON
	// -----------------------------------------------
	bool DataFile::load() {
		bool BINARY = false;
		bool ret = false;
		char buffer[64];
		// check length
		StopWatch s;
		s.start();
		sprintf_s(buffer, 64, "content\\%s", getFileName());
		// FIXME: assert that file name contains .
		LOG << "Reading simplified json file: " << buffer;
		JSONReader reader;
		if (BINARY) {
			sprintf_s(buffer, 64, "assets\\%u", string::murmur_hash(getFileName()));
			if (reader.load_binary(buffer)) {
				ret = loadData(reader);
			}
		}
		else {
			if (reader.parse(buffer)) {
				ret = loadData(reader);
			}
			if (ret) {
				sprintf_s(buffer, 64, "assets\\%u", string::murmur_hash(getFileName()));
				LOG << "saving binary file: " << buffer;
				reader.save_binary(buffer);
			}
		}
		if (!ret) {
			LOG << "Error: Cannot parse file: " << buffer;
			ret = false;
		}		
		s.end();
		LOG << "----> elapsed: " << s.elapsed();
		return ret;
	}
Exemple #2
0
TEST(JSON, read_err) {

	std::stringstream ss;
	JSONReader reader;

	ASSERT_ANY_THROW(reader.parse("[,]"));
	ASSERT_ANY_THROW(reader.parse("[],"));
	ASSERT_ANY_THROW(reader.parse("{a:1}"));

}
Exemple #3
0
	bool SpriteSheet::loadData(const JSONReader& loader) {
		int categories[256];
		int num = loader.get_categories(categories, 256);
		for (int i = 0; i < num; ++i) {
			Rect r;
			loader.get(categories[i], "rect", &r);
			const char* sn = loader.get_string(categories[i], "name");
			add(sn, r);
		}
		return true;
	}
void ChromiumProfileImporter::ReadProfiles(vector<ChromeProfileInfo> *cp,
                                           FilePath profileDirectory) {
  FilePath profileFileName = profileDirectory.AppendASCII("Local State");
  if (!PathExists(profileFileName))
    return;

  string input;
  ReadFileToString(profileFileName, &input);

  JSONReader reader;
  scoped_ptr<Value> root(reader.ReadToValue(input));

  DictionaryValue* dict = NULL;
  if (!root->GetAsDictionary(&dict)) {
    return;
  }

  const Value* roots;
  if (!dict->Get("profile", &roots)) {
    return;
  }

  const DictionaryValue* roots_d_value =
    static_cast<const DictionaryValue*>(roots);

  const Value* vInfoCache;
  const DictionaryValue* vDictValue;
  if (roots_d_value->Get("info_cache", &vInfoCache)) {

    vInfoCache->GetAsDictionary(&vDictValue);
    for (DictionaryValue::Iterator it(*vDictValue); !it.IsAtEnd(); it.Advance()){
      const Value* child_copy = &it.value();
      string profileName = it.key();

      const DictionaryValue* roots_sd_value =
        static_cast<const DictionaryValue*>(&it.value());

      ChromeProfileInfo prof;
      const Value* namVal;
      if (roots_sd_value->Get("name", &namVal)) {
        string16 displayName;
        namVal->GetAsString(&displayName);
        prof.profileDisplayName = displayName;
      } else {
        prof.profileDisplayName = base::UTF8ToUTF16(profileName);
      }
      prof.profileName = profileName;
      cp->push_back(prof);
    }

  }
}
Exemple #5
0
TEST(JSON, read) {

	JSONReader reader;
	JSONValue val = reader.parse("{\"a\": 1337, \"b\": false, \"c\":null, \"d\":[1,2,3], \"e\":{\"abc\":\"xyz\"} }");
	JSONObject* obj = val.asObject();

	ASSERT_EQ(1337, obj->getInt("a"));
	ASSERT_EQ(false, obj->getBoolean("b"));
	ASSERT_TRUE(obj->containsValue("c"));
	ASSERT_EQ(1, obj->getArray("d")->get(0).asInt());
	ASSERT_EQ(2, obj->getArray("d")->get(1).asInt());
	ASSERT_EQ(3, obj->getArray("d")->get(2).asInt());
	ASSERT_EQ("xyz", obj->getObject("e")->getString("abc"));
}
Exemple #6
0
	bool SpriteSheet::reloadData(const JSONReader& loader) {
		int categories[256];
		int num = loader.get_categories(categories, 256);
		for (int i = 0; i < num; ++i) {
			Rect r;
			loader.get(categories[i], "rect", &r);
			const char* sn = loader.get_string(categories[i], "name");
			int idx = findIndex(sn);
			if (idx == -1) {
				add(sn, r);
			}
			else {
				SheetEntry& se = _entries[idx];
				se.texture = Texture(r);
			}
		}
		return true;
	}
Exemple #7
0
// static
Value* JSONReader::ReadAndReturnError(const std::string& json,
                                      bool allow_trailing_comma, int* error_code_out,
                                      std::string* error_msg_out)
{
    JSONReader reader = JSONReader();
    Value* root = reader.JsonToValue(json, true, allow_trailing_comma);
    if(root)
    {
        return root;
    }

    if(error_code_out)
    {
        *error_code_out = reader.error_code();
    }
    if(error_msg_out)
    {
        *error_msg_out = reader.GetErrorMessage();
    }

    return NULL;
}
Exemple #8
0
		RID MeshBufferParser::parse(JSONReader& reader, int childIndex) {
			MeshBufferDescriptor descriptor;
			reader.get(childIndex, "size", &descriptor.size);
			const char* indexBufferName = reader.get_string(childIndex, "index_buffer");
			descriptor.indexBuffer = find(indexBufferName, ResourceType::INDEXBUFFER);
			const char* constantBufferName = reader.get_string(childIndex, "constant_buffer");
			descriptor.constantBuffer = find(constantBufferName, ResourceType::CONSTANTBUFFER);
			const char* vertexBufferName = reader.get_string(childIndex, "vertex_buffer");
			descriptor.vertexBuffer = find(vertexBufferName, ResourceType::VERTEXBUFFER);
			const char* materialName = reader.get_string(childIndex, "material");
			descriptor.material = find(materialName, ResourceType::MATERIAL);
			const char* name = reader.get_string(childIndex, "name");
			return createMeshBuffer(name, descriptor);
		}
Exemple #9
0
		RID BlendStateParser::parse(JSONReader& reader, int childIndex) {
			BlendStateDescriptor descriptor;
			const char* entry = reader.get_string(childIndex, "src_blend");
			descriptor.srcBlend = findBlendStateMapping(entry);
			entry = reader.get_string(childIndex, "dest_blend");
			descriptor.destBlend = findBlendStateMapping(entry);
			entry = reader.get_string(childIndex, "src_blend_alpha");
			descriptor.srcAlphaBlend = findBlendStateMapping(entry);
			entry = reader.get_string(childIndex, "dest_blend_alpha");
			descriptor.destAlphaBlend = findBlendStateMapping(entry);
			reader.get(childIndex, "alpha_enabled", &descriptor.alphaEnabled);
			const char* name = reader.get_string(childIndex, "name");
			return createBlendState(name, descriptor);
		}
Exemple #10
0
bool SerializerJSON::fromString(Variant & obj, const std::string & string)
{
    JSONReader reader;
    return reader.parse(string, obj);
}
Exemple #11
0
		RID IndexBufferParser::parse(JSONReader& reader, int childIndex) {
			IndexBufferDescriptor descriptor;
			reader.get(childIndex, "size", &descriptor.size);
			const char* name = reader.get_string(childIndex, "name");
			return createIndexBuffer(name, descriptor);
		}
Exemple #12
0
TEST(JSON, read_ok) {

	std::stringstream ss;
	JSONReader reader;
	JSONWriter writer(ss, false);

	JSONValue e0 = reader.parse("[]");
	ss.str(""); writer.write(e0);
	ASSERT_EQ("[]", ss.str());

	JSONValue e1 = reader.parse("{}");
	ss.str(""); writer.write(e1);
	ASSERT_EQ("{}", ss.str());

	JSONValue e2 = reader.parse("[ {},	{}, {},{}]");
	ss.str(""); writer.write(e2);
	ASSERT_EQ("[{},{},{},{}]", ss.str());

	JSONValue e3 = reader.parse("[ { }, [ {},{},{} ] ]");
	ss.str(""); writer.write(e3);
	ASSERT_EQ("[{},[{},{},{}]]", ss.str());

	JSONValue e4 = reader.parse("{\"a\":{}}");
	ss.str(""); writer.write(e4);
	ASSERT_EQ("{\"a\":{}}", ss.str());

	JSONValue e5 = reader.parse("{ \"a\" : [] }");
	ss.str(""); writer.write(e5);
	ASSERT_EQ("{\"a\":[]}", ss.str());

	JSONValue e6 = reader.parse("{ \"a\" : null }");
	ss.str(""); writer.write(e6);
	ASSERT_EQ("{\"a\":null}", ss.str());

	JSONValue e7 = reader.parse(" { } ");
	ss.str(""); writer.write(e7);
	ASSERT_EQ("{}", ss.str());

	JSONValue e8 = reader.parse("[ null , true, false ,1, 1.1] ");
	ss.str(""); writer.write(e8);
	ASSERT_EQ("[null,true,false,1,1.1]", ss.str());

	JSONValue e10 = reader.parse("[ {\"xyz\":133.7, \"abc\":\"11\\\"1\"},	[ { }, [ {},{},{} ] ]	,	[{\"a\":true}], [{\"b\":true}, {\"b\":false}] ]");
	ss.str(""); writer.write(e10);
	ASSERT_EQ("[{\"abc\":\"11\\\"1\",\"xyz\":133.7},[{},[{},{},{}]],[{\"a\":true}],[{\"b\":true},{\"b\":false}]]", ss.str());

}
Exemple #13
0
		RID ParticleManagerParser::parse(JSONReader& reader, int childIndex) {
			ParticleSystemsDescriptor descriptor;
			reader.get(childIndex, "sprite_buffer", &descriptor.spriteBuffer);
			const char* name = reader.get_string(childIndex, "name");
			return createParticleManager(descriptor);
		}
Exemple #14
0
void MainMenuController::preload() {
	// Tutorial button
	GameController* gc = GameController::create(TUTORIAL_KEY, TUTORIAL_FILE);
	gc->preload();
	_tutButt = MainMenuButton::create(gc);
	_tutButt->index = -1;
	_tutButt->loadTextures("textures/Tutorial/tutorial.png", "textures/Tutorial/tutorial.png");
	_tutButt->setTouchEnabled(true);
	//Add event listener
	_tutButt->addTouchEventListener([&](Ref* sender, ui::Widget::TouchEventType type) {
		switch (type) {
		case ui::Widget::TouchEventType::ENDED:
			_tutButt = ((MainMenuButton*)sender);
			_currController = _tutButt->index;
			_activeController = _tutButt->getController();
			_rootnode->removeAllChildren();
			_activeController->initialize(_rootnode);
		}
	});
	_tutButt->retain();

	loadGameController(LEVEL_ONE_KEY, LEVEL_ONE_FILE);
	loadGameController(LEVEL_TWO_KEY, LEVEL_TWO_FILE);
	loadGameController(LEVEL_THREE_KEY, LEVEL_THREE_FILE);
	loadGameController(LEVEL_FOUR_KEY, LEVEL_FOUR_FILE);
	loadGameController(LEVEL_FIVE_KEY, LEVEL_FIVE_FILE);
	loadGameController(LEVEL_SIX_KEY, LEVEL_SIX_FILE);
	loadGameController(LEVEL_SEVEN_KEY, LEVEL_SEVEN_FILE);
	loadGameController(LEVEL_EIGHT_KEY, LEVEL_EIGHT_FILE);
	loadGameController(LEVEL_NINE_KEY, LEVEL_NINE_FILE);

	// Load the textures (Autorelease objects)
	_assets = AssetManager::getInstance()->getCurrent();
	TextureLoader* tloader = (TextureLoader*)_assets->access<Texture2D>();
	tloader->loadAsync(EXPOSURE_BAR, "textures/exposure_bar.png");
	tloader->loadAsync(EXPOSURE_FRAME, "textures/exposure_bar_frame.png");
	tloader->loadAsync(DUDE_TEXTURE, "textures/player_animation.png");
	tloader->loadAsync("dudepool", "textures/Level Pool/Shade_Swim_Animation.png");
	tloader->loadAsync(PEDESTRIAN_TEXTURE, "textures/Pedestrian.png");
	tloader->loadAsync(PEDESTRIAN_SHADOW_TEXTURE, "textures/Pedestrian_S.png");
	tloader->loadAsync(PEDESTRIAN_POOL_TEXTURE, "textures/Level Pool/Level2_RotationP_Animation_New.png");
	tloader->loadAsync(PEDESTRIAN_POOL_SHADOW_TEXTURE, "textures/Level2_RotationP_Animation_S.png");
	tloader->loadAsync(INDICATOR, "textures/indicator.png");
	tloader->loadAsync(CAR_TEXTURE, "textures/car_animation.png");
	tloader->loadAsync(CAR_SHADOW_TEXTURE, "textures/Car1_S.png");
	tloader->loadAsync(GOAL_TEXTURE, "textures/caster_animation.png");
	//tloader->loadAsync("goalpool", "textures/caster_animation.png");
    tloader->loadAsync(WIN_IMAGE, "textures/menu/Win Icon.png");
    tloader->loadAsync(LOSE_IMAGE, "textures/menu/lose_icon.png");
	tloader->loadAsync(WIN_TEXTURE, "textures/Shade_Win.png");
	tloader->loadAsync(LOSE_TEXTURE, "textures/Shade_Sun.png");

	_assets->loadAsync<Sound>(GAME_MUSIC, "sounds/DD_Main.mp3");
	_assets->loadAsync<Sound>(WIN_MUSIC, "sounds/win.mp3");
	_assets->loadAsync<Sound>(LOSE_MUSIC, "sounds/lose.mp3");
	_assets->loadAsync<Sound>(LATCH_SOUND, "sounds/latch.mp3");
	_assets->loadAsync<Sound>(SIGHTED_SOUND, "sounds/sighted.mp3");
	_assets->loadAsync<Sound>(RUN_SOUND, "sounds/run.mp3");

	JSONReader reader;
	reader.initWithFile(STATIC_OBJECTS);
	if (!reader.startJSON()) {
		CCASSERT(false, "Failed to load static objects");
		return;
	}
	int count = reader.startArray("types");
	for (int index = 0; index < count; index++) {
		reader.startObject();
		string name = reader.getString("name");
		string imageFormat = reader.getString("imageFormat");
		string shadowImageFormat = reader.getString("shadowImageFormat");
		if (shadowImageFormat == "") {
			shadowImageFormat = imageFormat;
		}
		tloader->loadAsync(name + OBJECT_TAG, "textures/static_objects/" + name + "." + imageFormat);
		tloader->loadAsync(name + SHADOW_TAG, "textures/static_objects/" + name + "_S." + shadowImageFormat);
		reader.endObject();
		reader.advance();
	}
	reader.endArray();
	reader.endJSON();

	// Background
	tloader->loadAsync(MENU_BACKGROUND_KEY, "textures/menu/Level Background-01.png");
}