Пример #1
0
	void MapCommand::invoke(vector<string>& parameters) {
		cout << "Map command." << endl;
		if (parameters.size() > 0) {
			TestMode* mode = dynamic_cast<TestMode*>(m_game->getMode(BlockWorld::TEST_MODE));
			if (mode) {
				cout << "Found mode." << endl;
				MapLoader* loader = new MapLoader();
				MapDirectory* map = NULL;
				
				loader->loadDirectory("Resources/Maps");
				
				list<MapDirectory*>& maps = loader->getMaps();
				list<MapDirectory*>::iterator it = maps.begin();
				
				for ( ; it != maps.end(); it++) {
					cout << "Map: " << (*it)->getDirectoryName() << " (" << parameters[0] << ")" << endl;
					if ((*it)->getDirectoryName().compare(parameters[0]) == 0) {
						map = *it;
						break;
					}
				}
				
				if (map) {
					cout << "Found map." << endl;
					mode->setMap(map);
					m_game->setCurrentMode(BlockWorld::TEST_MODE);
				}
				
				delete loader;
			}
		}
	}
Пример #2
0
    void MenuScene::Initialize()
    {
        camera = new Camera(Vector2(0, 0), Vector2(game->Render->GetWidth(), game->Render->GetHeight()));
        camVelocity = Vector2(0.4, 0.7);

        MapLoader* ml = new MapLoader(this->game);
        Map = ml->LoadMap("maps/mainmenu.xml", this);
        delete ml;

        // Setup buttons
        singleButton = new Button(game, game->Content->LoadTexture("gui/buttons/Green250.png"),
                game->Content->LoadTexture("gui/buttons/Hover250.png"),
                framework::Rectangle(game->Render->GetWidth() / 2 - 100, game->Render->GetHeight() / 2 - 100, 200, 40), this);
        singleButton->LButtonDownCallback = &singlePlayerButtonDown;

        multiButton = new Button(game, game->Content->LoadTexture("gui/buttons/Green250.png"),
                game->Content->LoadTexture("gui/buttons/Hover250.png"),
                framework::Rectangle(game->Render->GetWidth() / 2 - 100, game->Render->GetHeight() / 2 - 50, 200, 40), this);

        settingsButton = new Button(game, game->Content->LoadTexture("gui/buttons/Blue250.png"),
                game->Content->LoadTexture("gui/buttons/Hover250.png"),
                framework::Rectangle(game->Render->GetWidth() / 2 - 100, game->Render->GetHeight() / 2, 200, 40), this);

        exitButton = new Button(game, game->Content->LoadTexture("gui/buttons/Red250.png"),
                game->Content->LoadTexture("gui/buttons/Hover250.png"),
                framework::Rectangle(game->Render->GetWidth() / 2 - 100, game->Render->GetHeight() / 2 + 50, 200, 40), this);
        exitButton->LButtonDownCallback = &exitButtonDown;

        Scene::Initialize();
    }
Пример #3
0
int main(int argc, char **argv)
{
	QCoreApplication application(argc, argv);
	QStringList arguments = application.arguments();

	if(arguments.count() > 1)
	{
		QString baseName = arguments[1];
		QString outputFilename = QStringEx::format("%1.map", baseName);
		QFile outputFile(outputFilename);

		if(outputFile.open(QIODevice::WriteOnly))
		{
			MapLoader mapLoader;
			Map map = mapLoader.load(baseName);

			QDataStream stream(&outputFile);
			stream << map;
		}
		else
		{
			qDebug() << "Could not open output file for writing";
		}
	}

	return 0;
}
Пример #4
0
void ECBSSearch::printPaths(const MapLoader& ml) {
  for (size_t i = 0; i < paths.size(); i++) {
    cout << "AGENT " << i << " Path: ";
    for (auto& entry : *paths[i]) {
      std::cout << entry.location << " " << entry.action << ", ";
    }
    cout << endl;
  }



    {
      using namespace pt;

      ptree pt;
      ptree agents;
      for (size_t ag = 0; ag < paths.size(); ag++) {
        ptree agent;
        std::stringstream sstr;
        sstr << "create" << ag + 1;
        agent.put("name", sstr.str());
        ptree path;
        size_t t = 0;
        for (auto& entry : *paths[ag]) {
          ptree pathentry;
          pathentry.put("x", ml.col_coordinate(entry.location));
          pathentry.put("y", ml.row_coordinate(entry.location));
          pathentry.put("theta", theta(entry.orientation));
          pathentry.put("arrival", t);

          path.push_back(std::make_pair("", pathentry));
          ++t;
        }
        agent.add_child("path", path);
        agents.push_back(std::make_pair("", agent));
      }
      pt.add_child("agents", agents);
      write_json("schedule_discrete.json", pt);

    }


}
Пример #5
0
	void NetworkTestMode::onLoadMap(LoadMapMessage& message)
	{
		performStop();
		
		MapLoader* loader = new MapLoader();
		MapDirectory* map = NULL;
		
		loader->loadDirectory("Resources/Maps");
		
		list<MapDirectory*>& maps = loader->getMaps();
		list<MapDirectory*>::iterator it = maps.begin();
		
		for ( ; it != maps.end(); it++) {
			if ((*it)->getDirectoryName().compare(message.getName()) == 0) {
				map = *it;
				break;
			}
		}
		
		if (map) {
			Engine* engine = m_game->getEngine();
			
			ImageMapWorldCreator* worldCreator = new ImageMapWorldCreator();
			m_world = worldCreator->createWorld(*engine, *map);
			
			m_camera = new MouseScrollCamera(*m_world, *engine);
			
			delete worldCreator;
			
			m_objectManager = new ObjectManager();
			
			m_gibLoader = new GibResourceLoader(*engine);
			m_gibLoader->loadFile("Resources/Gibs/gibs.xml");
			
			// If we get here the map should be successfully loaded ;)
			// Therefore we send the message to the server.
			MapLoadedMessage loaded(m_thisNetworkID);
			m_game->getNetwork()->sendMessage(loaded);
		}

		delete loader;
	}
Пример #6
0
// Load all maps from the resources folder
void loadMaps()
{
	MapLoader loader;
	int fIndex = agk::OpenToRead("maps.dat");
	string line;
	int counter = 0;

	while(!agk::FileEOF(fIndex))
	{
		line = agk::ReadLine(fIndex);

		loader.loadFile(line.c_str());

		tracks[counter] = loader.getTrack();

		counter++;
	}
	
	agk::CloseFile(fIndex);
}
Пример #7
0
int MapTileLayer::_tileRegion(const Coordinate& a, const Coordinate& b, int lod, bool async)
{
    MapLoader* loader = MapViewLayer::Context.Loader;
    auto ai = loader->getTileIndex(a, lod);
    auto bi = loader->getTileIndex(b, lod);
    Coordinate size = loader->getTileSize(lod);
    
    cocos2d::log("Map rebuild (%d,%d) (%d,%d)", ai.first, ai.second, bi.first, bi.second);
    int tilesNotYetLoaded = 0;
    for(int i = ai.second; i <= bi.second; ++i) // y axis
    {
        for(int j = ai.first; j <= bi.first; ++j) // x axis
        {
            Coordinate position = Coordinate(j*size.x, i*size.y);
            const MapTileInfo& tileInfo = loader->getMapTileInfo({j, i}, lod);
            tilesNotYetLoaded += addTile(tileInfo, position, size, async);
        }
    }
    return tilesNotYetLoaded;
}
Пример #8
0
void GameManager::Run()
{
	std::string title("Ball Game");
	DrawManager::Instance()->CreateWindow( title, 1360, 768, true, 60 );

	ComponentRegistrator::Register( *ComponentFactory::Instance() );

	ObjectTemplateManager::Instance()->LoadObjects( std::string("../resources/data/objects/") );

	MapLoader loader;
	loader.LoadMap( std::string( "../resources/data/maps/protomap/" ) );
	ObjectManager::Instance()->InitAllObjects();

	Camera::Instance()->SetActiveCameraID( 0 );

	sf::RenderWindow* windowPtr = DrawManager::Instance()->Window();

	while( windowPtr->isOpen() )
	{
		input->ResetKeyStates();
		sf::Event event;
		while( windowPtr->pollEvent( event ) )
		{
			if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape)
			{
				windowPtr->close();
			}
			input->PollInput( event );
		}

		float delta = fpsTimer->GetMilliseconds();
		fpsTimer->Restart();

		PhysicsManager::Instance()->Step();
		Camera::Instance()->Update( delta );
		ObjectManager::Instance()->UpdateObjects( delta );

		DrawManager::Instance()->Render();
	}
}
Пример #9
0
void MapTileLayer::tileRegion(const Coordinate& a, const Coordinate& b, int lod)
{
    MapLoader* loader = MapViewLayer::Context.Loader;
    
    auto ai = loader->getTileIndex(a, lod);
    auto bi = loader->getTileIndex(b, lod);
    
    if(ai == m_indexA && bi == m_indexB && m_lod == lod){
        // don't rebuild map
        return;
    }
    removeAllChildren();
    m_indexA = ai;
    m_indexB = bi;
    m_lod = lod;
    
    int tilesPending = _tileRegion(a, b, lod, true);
    if(tilesPending > 0)
    {
        _tileRegion(a, b, lod+1, false);
    }
}
void ResourcesLoader::loadGameData()
{
	MapLoader mapLoader;
	mapLoader.loadFromFile();
	_resHolder->setData(mapLoader.getMapsData());
	_resHolder->setData(mapLoader.loadSpecialMaps(), true);

	EnemiesLoader enemiesLoader(_errorHandler);
	enemiesLoader.loadFromFile();
	_resHolder->setData(enemiesLoader.getEnemiesData());
	_resHolder->setData(enemiesLoader.getSpecialEnemiesData(), true);

	WeaponsLoader weaponsLoader(_errorHandler);
	weaponsLoader.loadFromFile();
	_resHolder->setData(weaponsLoader.getWeaponsData());

	ArmoursLoader armoursLoader(_errorHandler);
	armoursLoader.loadFromFile();
	_resHolder->setData(armoursLoader.getArmoursData());

	ConsumablesLoader consumablesLoader(_errorHandler);
	consumablesLoader.loadFromFile();
	_resHolder->setData(consumablesLoader.getConsumablesData());
}
Пример #11
0
void CoronaRenderer::defineMesh(mtco_MayaObject *obj)
{
	MObject meshObject = obj->mobject;
	MStatus stat = MStatus::kSuccess;
	
	bool hasDisplacement = false;
	Corona::Abstract::Map *displacementMap = NULL;
	float displacementMin = 0.0f;
	float displacementMax = 0.01f;

	// I do it here for displacement mapping, maybe we should to another place
	getObjectShadingGroups(obj->dagPath, obj->perFaceAssignments, obj->shadingGroups);
	if( obj->shadingGroups.length() > 0)
	{
		MFnDependencyNode shadingGroup(obj->shadingGroups[0]);
		MString sgn = shadingGroup.name();
		MObject displacementObj = getConnectedInNode(obj->shadingGroups[0], "displacementShader");
		MString doo = getObjectName(displacementObj);

		if( (displacementObj != MObject::kNullObj) && (displacementObj.hasFn(MFn::kDisplacementShader)))
		{
			MObject displacementMapObj = getConnectedInNode(displacementObj, "displacement");
			if( (displacementMapObj != MObject::kNullObj) && (displacementMapObj.hasFn(MFn::kFileTexture)))
			{
				MFnDependencyNode displacmentMapNode(displacementObj);
				getFloat("mtco_displacementMin", displacmentMapNode, displacementMin);
				getFloat("mtco_displacementMax", displacmentMapNode, displacementMax);
				MString fileTexturePath = getConnectedFileTexturePath(MString("displacement"), displacmentMapNode);
				if( fileTexturePath != "")
				{
					MapLoader loader;
					displacementMap = loader.loadBitmap(fileTexturePath.asChar());
					hasDisplacement = true;
				}
			}
		}
	}
	
	MFnMesh meshFn(meshObject, &stat);
	CHECK_MSTATUS(stat);

	MItMeshPolygon faceIt(meshObject, &stat);
	CHECK_MSTATUS(stat);

	MPointArray points;
	meshFn.getPoints(points);
	MFloatVectorArray normals;
	meshFn.getNormals( normals, MSpace::kWorld );
	MFloatArray uArray, vArray;
	meshFn.getUVs(uArray, vArray);

	//logger.debug(MString("Translating mesh object ") + meshFn.name().asChar());
	MString meshFullName = makeGoodString(meshFn.fullPathName());

	Corona::TriangleData td;
	
	Corona::IGeometryGroup* geom = NULL;
	
	geom = this->context.scene->addGeomGroup();
	obj->geom = geom;

	for( uint vtxId = 0; vtxId < points.length(); vtxId++)
	{
		geom->getVertices().push(Corona::Pos(points[vtxId].x,points[vtxId].y,points[vtxId].z));
	}
	
	for( uint nId = 0; nId < normals.length(); nId++)
	{
		geom->getNormals().push(Corona::Dir(normals[nId].x,normals[nId].y,normals[nId].z));
	}

	for( uint tId = 0; tId < uArray.length(); tId++)
	{
		geom->getMapCoords().push(Corona::Pos(uArray[tId],vArray[tId],0.0f));
		geom->getMapCoordIndices().push(geom->getMapCoordIndices().size());
	}   

	MPointArray triPoints;
	MIntArray triVtxIds;
	MIntArray faceVtxIds;
	MIntArray faceNormalIds;


	for(faceIt.reset(); !faceIt.isDone(); faceIt.next())
	{
		int faceId = faceIt.index();
		int numTris;
		faceIt.numTriangles(numTris);
		faceIt.getVertices(faceVtxIds);

		MIntArray faceUVIndices;

		faceNormalIds.clear();
		for( uint vtxId = 0; vtxId < faceVtxIds.length(); vtxId++)
		{
			faceNormalIds.append(faceIt.normalIndex(vtxId));
			int uvIndex;
			faceIt.getUVIndex(vtxId, uvIndex);
			faceUVIndices.append(uvIndex);
		}

		for( int triId = 0; triId < numTris; triId++)
		{
			int faceRelIds[3];
			faceIt.getTriangle(triId, triPoints, triVtxIds);

			for( uint triVtxId = 0; triVtxId < 3; triVtxId++)
			{
				for(uint faceVtxId = 0; faceVtxId < faceVtxIds.length(); faceVtxId++)
				{
					if( faceVtxIds[faceVtxId] == triVtxIds[triVtxId])
					{
						faceRelIds[triVtxId] = faceVtxId;
					}
				}
			}
			
			uint vtxId0 = faceVtxIds[faceRelIds[0]];
			uint vtxId1 = faceVtxIds[faceRelIds[1]];
			uint vtxId2 = faceVtxIds[faceRelIds[2]];
			uint normalId0 = faceNormalIds[faceRelIds[0]];
			uint normalId1 = faceNormalIds[faceRelIds[1]];
			uint normalId2 = faceNormalIds[faceRelIds[2]];
			uint uvId0 = faceUVIndices[faceRelIds[0]];
			uint uvId1 = faceUVIndices[faceRelIds[1]];
			uint uvId2 = faceUVIndices[faceRelIds[2]];


			if( hasDisplacement )
			{
				Corona::DisplacedTriangleData tri;
				tri.displacement.map = displacementMap;
				MPoint p0 = points[vtxId0];
				MPoint p1 = points[vtxId1];
				MPoint p2 = points[vtxId2];
				tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
				tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
				tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
				MVector n0 = normals[normalId0];
				MVector n1 = normals[normalId1];
				MVector n2 = normals[normalId2];
				Corona::Dir dir0(n0.x, n0.y, n0.z);
				Corona::Dir dir1(n1.x, n1.y, n1.z);
				Corona::Dir dir2(n2.x, n2.y, n2.z);
				tri.n[0] = Corona::AnimatedDir(dir0);
				tri.n[1] = Corona::AnimatedDir(dir1);
				tri.n[2] = Corona::AnimatedDir(dir2);
				Corona::Pos uv0(uArray[uvId0],vArray[uvId0],0.0);
				Corona::Pos uv1(uArray[uvId1],vArray[uvId1],0.0);
				Corona::Pos uv2(uArray[uvId2],vArray[uvId2],0.0);
				Corona::StaticArray<Corona::Pos, 3> uvp;
				uvp[0] = uv0;
				uvp[1] = uv1;
				uvp[2] = uv2;
				tri.t.push(uvp);
				tri.materialId = 0;
				tri.displacement.min = displacementMin;
				tri.displacement.max = displacementMax;
				geom->addPrimitive(tri);			
			}else{
				Corona::TriangleData tri;
				tri.v = Corona::AnimatedPosI3(vtxId0, vtxId1, vtxId2);
				tri.n = Corona::AnimatedDirI3(normalId0, normalId1, normalId2);
				tri.t[0] = uvId0;
				tri.t[1] = uvId1;
				tri.t[2] = uvId2;
				tri.materialId = 0;
				geom->addPrimitive(tri);			
			}

		}		
	}
}
Пример #12
0
CBSSearch::CBSSearch(MapLoader& ml, const AgentsLoader& al, const EgraphReader& egr, double e_w, bool tweak_g_val) {
	cols = ml.cols;
	num_expanded = 0;
	num_of_types = al.num_of_types;
	nums_of_agents = al.nums_of_agents;
	map_size = ml.rows*ml.cols;
	solution_found = false;
	solution_cost = -1;
	current_makespan = 0;
	max_makespan = 1.5 * (ml.rows + ml.cols);
	start_locations = vector<vector<int>>(num_of_types);
	goal_locations = vector<vector<int>>(num_of_types);
	search_engines = vector < SingleTypeSearch* >(num_of_types);

	for (int t = 0; t < num_of_types; t++) {
		vector<int> init_locs_list(nums_of_agents[t]);
		vector<int> goal_locs_list(nums_of_agents[t]);
		for (int i = 0; i < nums_of_agents[t]; i++) {
			int init_loc = ml.linearize_coordinate(al.initial_locations[t][i].first, al.initial_locations[t][i].second);
			int goal_loc = ml.linearize_coordinate(al.goal_locations[t][i].first, al.goal_locations[t][i].second);
			init_locs_list[i] = init_loc;
			goal_locs_list[i] = goal_loc;
		}
		start_locations[t] = init_locs_list;
		goal_locations[t] = goal_locs_list;
		
		//determine starting makespan
		for (int i = 0; i < nums_of_agents[t]; i++) {
			int min_distance_to_a_goal = map_size;
			//vector<int> distances = ml.getDistancesToAllLocations(init_locs_list[i]);
			//ComputeHeuristic ch(goal_locs_list[i], ml.get_map(), ml.rows*ml.cols, ml.actions_offset, e_w, &egr);
			for (int j = 0; j < nums_of_agents[t]; j++) {				
				//int manhattan_distance = distances[goal_locs_list[j]];
				int manhattan_distance = abs(ml.row_coordinate(init_locs_list[i]) - ml.row_coordinate(goal_locs_list[j])) + abs(ml.col_coordinate(init_locs_list[i]) - ml.col_coordinate(goal_locs_list[j]));
				min_distance_to_a_goal = (manhattan_distance < min_distance_to_a_goal) ? manhattan_distance : min_distance_to_a_goal;
			}
			current_makespan = (current_makespan < min_distance_to_a_goal) ? min_distance_to_a_goal : current_makespan;
		}
	}

	// initialize paths_found_initially (contain all individual optimal policies)
	paths_found_initially.resize(num_of_types);
	
	
	bool all_agents_found_path = true;

	std::clock_t start;
	start = std::clock();
	
	for (int t = 0; t < num_of_types; t++) {
		paths = paths_found_initially;

		search_engines[t] = new SingleTypeSearch(t, start_locations[t], goal_locations[t],
			NULL,
			ml.get_map(), ml.rows, ml.cols, ml.actions_offset,
			&egr,
			e_w,
			tweak_g_val);

		for (this->current_makespan; this->current_makespan <= max_makespan; this->current_makespan++) {
			if (search_engines[t]->findPath(paths, current_makespan) == true) {
				paths_found_initially[t] = new vector<vector<int> >(*search_engines[t]->getPath());
				break;
			}
		}
		if (current_makespan == max_makespan) {
			all_agents_found_path = false;
		}

	}

	pre_time = (std::clock() - start);

	if (all_agents_found_path == false) {
		cout << "NO SOLUTION EXISTS";
	}

	paths = paths_found_initially;


	dummy_start = new CBSNode();
	dummy_start->type_id = -1;
	dummy_start->g_val = current_makespan;//compute_g_val(num_of_types);
	dummy_start->open_handle = heap.push(dummy_start);
	current_makespan = dummy_start->g_val;
}
void InGameState::restart()
{
	if (m_io)
	{
		m_victoryTime = 0;
		m_defeatTime = 0;
		m_toneOutTimer = 0;
		m_io->clearSpriteInfos();
		for (unsigned int i = 0; i < m_gameObjects.size(); i++)
		{
			if( m_gameObjects[i] != NULL)
			{
				delete m_gameObjects[i];
				m_gameObjects[i] = NULL;
			}
		}
		m_gameObjects.clear();
		m_monsters.clear();
		m_bombs.clear();
		if (m_tileMap)
		{
			delete m_tileMap;
			m_tileMap = NULL;
		}
		if (m_gui)
		{
			delete m_gui;
			m_gui = NULL;
		}

		m_tileMap	= 0;
		MapLoader mapParser;

		int tscore = 0;
		if (m_stats)
		{
			tscore = m_stats->getTotalScore();
			delete m_stats;
		}
		m_stats = new GameStats(m_parent->getNewTimerInstance(), m_maps[m_currentMap].parTime, tscore);

		stringstream ss;
		ss << m_currentMap;
		string mapString = "../Maps/" + m_maps[m_currentMap].filename;
		mapParser.parseMap(mapString, m_io, m_stats, m_factory);

		m_tileMap = mapParser.getTileMap();
		m_gameObjects = mapParser.getGameObjects();
		m_avatar = mapParser.getAvatar();
		m_monsters = mapParser.getMonsters();
		m_traps = mapParser.getTraps();
		m_gui = mapParser.getGUI();
		m_paused = false;

		if (m_avatar)
			m_startTile = m_avatar->getCurrentTile();

		m_io->fadeSceneToBlack(1.0f);
	}

	m_parent->stopMainTimer();
	m_parent->startMainTimer();

	//Ugly - Should be corrected. Leave for now
	if (m_backgroundMusic)
	{
		m_backgroundMusic->deleted = true;
	}
	m_backgroundMusic = new SoundInfo();
	m_backgroundMusic->id = "../Sounds/Music/" + m_maps[m_currentMap].backgroundMusic;
	m_backgroundMusic->play = true;
	m_backgroundMusic->volume = 0;
	m_io->addSong(m_backgroundMusic);

	//Add sound effects
	if (m_clock)
	{
		m_clock->deleted = true;
	}
	m_clock = m_factory->CreateSoundInfo("../Sounds/bell.wav", 100);

	if (m_defeat)
	{
		m_defeat->deleted = true;
	}
	m_defeat = m_factory->CreateSoundInfo("../Sounds/failure.wav", 100);

	if (m_victory)
	{
		m_victory->deleted = true;
	}
	m_victory = m_factory->CreateSoundInfo("../Sounds/victory.wav", 100);


	//ANTON FIX!
	//Makes sure the game starts at time 0
	m_stats->getGameTimer()->stop();
	m_stats->getGameTimer()->start();
}
Пример #14
0
		void OgitorWorld::Load(const MapLoader &loader, const Register::Table &worldEntityDef)
		{
			const auto &hive = loader.GetStaticEntitiesHive();

			for(auto it : hive)		
			{
				Register::Table *dict = static_cast<Register::Table *>(it.second);

				try
				{
					const String_t &name = dict->GetString("name");
					const String_t &type = dict->GetString("typename");

					if(this->LoadGlobalObject(type, *dict))
						continue;

					//make sure this is not duplicated
					StaticObjectsMap_t::iterator objIt = m_mapStaticObjects.lower_bound(name);
					if((objIt != m_mapStaticObjects.end()) && !(m_mapStaticObjects.key_comp()(name, objIt->first)))
					{
						LogMakeStream() << "[OgitorWorld::Load] Static object " << name << " is duplicated\n";
						continue;
					}

					StaticObject_s object;
					if(!this->LoadStaticObject(object, name, type, *dict))
						continue;

					m_mapStaticObjects.insert(objIt, std::make_pair(name, object));

				}
				catch(Exception &ex)
				{
					LogMakeStream() << "[OgitorWorld::Load] Exception loading static object: " << ex.what();
				}
			}

			//time to fix parents
			for(StaticObjectsMap_t::value_type &pair : m_mapStaticObjects)
			{
				StaticObject_s &object = pair.second;

				if(StringIsBlank(object.strParent) || (object.strParent.compare("SceneManager") == 0))
					continue;

				StaticObjectsMap_t::iterator it = m_mapStaticObjects.find(object.strParent);
				if(it == m_mapStaticObjects.end())
				{
					LogMakeStream() << "[OgitorWorld::Load] Static object " << pair.first << " without parent " << object.strParent << "\n";
					continue;
				}

				if(object.m_pclSceneNode->getParent())
					object.m_pclSceneNode->getParent()->removeChild(object.m_pclSceneNode);
				it->second.m_pclSceneNode->addChild(object.m_pclSceneNode);
			}

			//configure physics
			Physics::Manager &physicsManager = Physics::Manager::GetInstance();

			Physics::CollisionTag staticCollisionTag = Physics::Settings::CreateStaticWorldCollisionTag();

			for(auto &pair : m_mapStaticObjects)
			{
				StaticObject_s &object = pair.second;

				if(object.m_pclEntity == NULL)
					continue;

				//Why using those _ functions: http://89.151.96.106/forums/viewtopic.php?f=22&t=62386
				//http://www.ogre3d.org/forums/viewtopic.php?p=221113
				//http://www.ogre3d.org/tikiwiki/-SceneNode
				Engine::Math::Transform transform(
					object.m_pclSceneNode->_getDerivedPosition(), 
					object.m_pclSceneNode->_getDerivedOrientation()
				);

				BaseOgreWorld::CreateStaticObjectRigidBody(object, transform, object.m_pclSceneNode->_getDerivedScale(), staticCollisionTag);
			}
		

			if(m_pclTerrainGroupTable != NULL)
			{
				this->LoadTerrainGroup(*m_pclTerrainGroupTable);
				m_pclTerrainGroupTable = NULL;
			}

			if(m_pclTerrainPageTable != NULL)
			{
				this->LoadTerrainPage(*m_pclTerrainPageTable, worldEntityDef);
				m_pclTerrainPageTable = NULL;
			}		
		}
Пример #15
0
void Scene::load(bool loadGameObjects)
{
    CoreSubsystem::getSingleton().getWorld()->clearScene();
    MapLoader* loader = new MapLoader();
    loader->loadScene(mMaps, loadGameObjects);
}
Пример #16
0
ECBSSearch::ECBSSearch(const MapLoader& ml, const AgentsLoader& al, const EgraphReader& egr, double e_w, double f_w, bool tweak_g_val) {
  focal_w = f_w;
  HL_num_expanded = 0;
  HL_num_generated = 0;
  LL_num_expanded = 0;
  LL_num_generated = 0;
  num_of_agents = al.num_of_agents;
  map_size = ml.rows*ml.cols;
  solution_found = false;
  solution_cost = -1;
  ll_min_f_vals = vector <double> (num_of_agents);
  paths_costs = vector <double> (num_of_agents);
  ll_min_f_vals_found_initially = vector <double> (num_of_agents);
  paths_costs_found_initially = vector <double> (num_of_agents);
  search_engines = vector < SingleAgentECBS* > (num_of_agents);
  for (int i = 0; i < num_of_agents; i++) {
    int init_loc = ml.linearize_coordinate((al.initial_locations[i]).first, (al.initial_locations[i]).second);
    int goal_loc = ml.linearize_coordinate((al.goal_locations[i]).first, (al.goal_locations[i]).second);
    ComputeHeuristic ch(goal_loc, ml.get_map(), ml.rows*ml.cols, ml.moves_offset, ml.actions_offset, e_w, &egr);
    search_engines[i] = new SingleAgentECBS(init_loc, goal_loc, MapLoader::orientation_t::FACE_EAST,
                                            ch.getHVals(),
                                            ml.get_map(), ml.rows*ml.cols,
                                            ml.moves_offset, ml.actions_offset,
                                            &egr,
                                            e_w,
                                            tweak_g_val);
  }

  // initialize allNodes_table (hash table)
  empty_node = new ECBSNode();
  empty_node->time_generated = -2; empty_node->agent_id = -2;
  deleted_node = new ECBSNode();
  deleted_node->time_generated = -3; deleted_node->agent_id = -3;
  allNodes_table.set_empty_key(empty_node);
  allNodes_table.set_deleted_key(deleted_node);

  // initialize all initial paths to NULL
  paths_found_initially.resize(num_of_agents);
  for (int ag=0; ag < num_of_agents; ag++)
    paths_found_initially[ag] = NULL;

  // initialize paths_found_initially
  for (int i = 0; i < num_of_agents; i++) {
    //    cout << "Computing initial path for agent " << i << endl; fflush(stdout);
    paths = paths_found_initially;
    size_t max_plan_len = getPathsMaxLength();
    bool* res_table = new bool[map_size * max_plan_len]();  // initialized to false
    updateReservationTable(res_table, max_plan_len, i);
    //    cout << "*** CALCULATING INIT PATH FOR AGENT " << i << ". Reservation Table[MAP_SIZE x MAX_PLAN_LEN]: " << endl;
    //    printResTable(res_table, max_plan_len);
    if ( search_engines[i]->findPath ( f_w, NULL, res_table, max_plan_len ) == false)
      cout << "NO SOLUTION EXISTS";
    paths_found_initially[i] = new vector<pathEntry> (*(search_engines[i]->getPath()));
    ll_min_f_vals_found_initially[i] = search_engines[i]->min_f_val;
    paths_costs_found_initially[i] = search_engines[i]->path_cost;
    LL_num_expanded += search_engines[i]->num_expanded;
    LL_num_generated += search_engines[i]->num_generated;
    delete[] res_table;
    //    cout << endl;
  }

  paths = paths_found_initially;
  ll_min_f_vals = ll_min_f_vals_found_initially;
  paths_costs = paths_costs_found_initially;

  // generate dummy start and update data structures
  dummy_start = new ECBSNode();
  dummy_start->agent_id = -1;
  dummy_start->g_val = 0;
  for (int i = 0; i < num_of_agents; i++)
    dummy_start->g_val += paths_costs[i];
  dummy_start->ll_min_f_val = 0;
  dummy_start->sum_min_f_vals = compute_hl_lower_bound();
  dummy_start->open_handle = open_list.push(dummy_start);
  dummy_start->focal_handle = focal_list.push(dummy_start);
  HL_num_generated++;
  dummy_start->time_generated = HL_num_generated;
  allNodes_table[dummy_start] = dummy_start;

  min_sum_f_vals = dummy_start->sum_min_f_vals;
  focal_list_threshold = focal_w * dummy_start->sum_min_f_vals;

  //  cout << "Paths in START (high-level) node:" << endl;
  //  printPaths();
  //  cout << "SUM-MIN-F-VALS: " << dummy_start->sum_min_f_vals << endl;
}
Пример #17
0
int main()
{
    init();
    map = mapLoader.FileMapper();
    int x = mapLoader.GetX();
    int y = mapLoader.GetY();
    char** mapArr = mapLoader.GetMap(map, x, y);
    char** safetyCopy = mapLoader.GetMap(map, x, y);
    ostringstream os;

    Image title = Image("title.txt");
    renderEngine.Render(title);
    getch();
    system("cls");
    mapArr[playerX][playerY] = '0';
    renderEngine.DrawMap(mapArr, x, y);

    while(true) {
        mapArr[playerX][playerY] = safetyCopy[playerX][playerY];
        switch(getch()) {
        case 'w':
            if(playerCanMove('w', safetyCopy[playerX][playerY-1])) {
                playerY--;
            }
            break;
        case 's':
            if(playerCanMove('s', safetyCopy[playerX][playerY+1])) {
                playerY++;
            }
            break;
        case 'a':
            if(playerCanMove('a', safetyCopy[playerX-1][playerY])) {
                playerX--;
            }
            break;
        case 'd':
            if(playerCanMove('d', safetyCopy[playerX+1][playerY])) {
                playerX++;
            }
            break;
        case '0':
            return EXIT_SUCCESS;
            break;
        default:
            break;
        }

        switch(command.Interact(safetyCopy[playerX][playerY])) {
        case 'a':
            pos++;
            os.str("");
            os << "next" << pos << ".txt";
            mapLoader.SetPath(os.str());
            renderEngine.SetEnvironment("fields");
            map = mapLoader.FileMapper();
            x = mapLoader.GetX();
            y = mapLoader.GetY();
            playerX = 20;
            playerY = 2;
            mapArr = mapLoader.GetMap(map, x, y);
            safetyCopy = mapLoader.GetMap(map, x, y);
            break;
        case 'p':
            pos--;
            os.str("");
            os << "next" << pos << ".txt";
            mapLoader.SetPath(os.str());
            renderEngine.SetEnvironment("house");
            map = mapLoader.FileMapper();
            x = mapLoader.GetX();
            y = mapLoader.GetY();
            playerX = 8;
            playerY = 12;
            mapArr = mapLoader.GetMap(map, x, y);
            safetyCopy = mapLoader.GetMap(map, x, y);
            break;
        case 'n':
            break;
        }
        system("cls");
        mapArr[playerX][playerY] = '0';
        renderEngine.DrawMap(mapArr, x, y);
    }

    return EXIT_SUCCESS;

}