예제 #1
0
int main() {
    bool test = false, simulateBathy = false;

    if (test) {
        runTests();
        return 0;
    }

    acousticParams.insert({ "debug", "0" });

    acousticParams.insert({ "cellSize", "5" });
    acousticParams.insert({ "fishmodel", "0" });
    acousticParams.insert({ "suppressionRangeFactor", "1"}),
    acousticParams.insert({ "suppressionMethod", "suppression.quick"}),
    acousticParams.insert({ "userSensors", "100,100,0,0,100,0,0,200" });
    acousticParams.insert({ "numOptimalSensors", "10" });
    acousticParams.insert({ "numProjectedSensors", "2" });
    acousticParams.insert({ "bias", "2" });

    acousticParams.insert({ "ousdx", ".1" });
    acousticParams.insert({ "ousdy", ".1" });
    acousticParams.insert({ "oucor", "0" });
    acousticParams.insert({ "mux", ".5" });
    acousticParams.insert({ "muy", ".5" });
    acousticParams.insert({ "fishmodel", "1" });
    acousticParams.insert({ "minDepth", "15" });
    acousticParams.insert({ "maxDepth", "30" });
    acousticParams.insert({ "meanRelativePosition", "1" });
    acousticParams.insert({ "relativePositionSD", "1" });
    // acousticParams.insert({"inputFile", "himbsyn.bathy.v19.grd"});
    acousticParams.insert({"inputFile", "himbsyn.bathytopo.1km.v19.grd"});
    // acousticParams.insert({ "inputFile", "pal_5m.asc" });
    acousticParams.insert({ "inputFileType", "netcdf" });
    acousticParams.insert({ "seriesName", "z" });
    acousticParams.insert({ "timestamp", "-1" });
    acousticParams.insert({ "logScaleGraphColoring", "1" });
    acousticParams.insert({ "contourDepths", "0,-20,-40,-80" });
    double suppressionRangeFactor =
                       std::stod(acousticParams["suppressionRangeFactor"]),
           ousdx     = std::stod(acousticParams["ousdx"]),
           ousdy     = std::stod(acousticParams["ousdy"]),
           oucor     = std::stod(acousticParams["oucor"]),
           mux       = std::stod(acousticParams["mux"]),
           muy       = std::stod(acousticParams["muy"]),
           fishmodel = std::stod(acousticParams["fishmodel"]),
           networkSparsity = 0, absRecoveryRate = 0, uniqueRecoveryRate = 0,
           goodnessGridComputationTime = 0, totalComputationTime = 0;

    int    startRow = 450,
           startCol = 340,  // 450,340,201,201 (1km)netcdf
           rowDist = 1001,   // 100 0 800 1500 (5m)netcdf
           colDist = 1001,   // 300 200 501 501 (palmyra) asc
           height = 1000,
           width = 1000,
           bias = 2,
           sensorDetectionRange = 4,
           sensorDetectionDiameter = 2 * sensorDetectionRange + 1,
           sensorPeakDetectionProbability = 1,
           SDofSensorDetectionRange = 1,
           i = 0,
           row = 0,
           col = 0,
           cellSize = std::stoi(acousticParams["cellSize"]),
           numOptimalSensors =
                   std::stoi(acousticParams["numOptimalSensors"]),
           numProjectedSensors =
                   std::stoi(acousticParams["numProjectedSensors"]),
           numSensorsToPlace = numOptimalSensors + numProjectedSensors,
           suppressionDiameter = (2 * ceil(sensorDetectionRange * suppressionRangeFactor)) + 1;
    // Set the global border size
    border = sensorDetectionRange;
    omp_set_num_threads(numThreads);
    Eigen::setNbThreads(numThreads);
    clock_t begin, end, vizBegin, vizEnd;




    // TODO(Greg) Data validation
    // Parse User Sensor Placements
    std::cout << "\nReading userSensor List...\n";
    std::vector<std::string> userSensors;
    parseCDString(&userSensors, acousticParams["userSensors"], ',');
    Eigen::MatrixXd userSensorList;
    userSensorList.resize(userSensors.size()/2, 4);
    for (i = 0; i < userSensorList.rows(); i ++) {
        row = std::stoi(userSensors[2 * i]);
        col = std::stoi(userSensors[2 * i + 1]);
        if (row < 0 || col < 0 || row >= rowDist || col >= colDist) {
            printError("A user-defined sensor is out of bounds.", 1,
                       acousticParams["timestamp"]);
        }
        // Translate user points to our internal grid
        userSensorList(i, 0) = row;
        userSensorList(i, 1) = col;
    }


    begin = clock();

    // Compute contour depth meta data (used for graphical output)
    std::vector<std::string> contourLevels;
    parseCDString(&contourLevels, acousticParams["contourDepths"], ',');
    // Note the number of contours we need to graph
    acousticParams.insert({ "numContourDepths",
                            std::to_string(contourLevels.size()) });

    // TODO(Greg) Sort is broken, throws segfaults.  Possibly b/c file doesn't
    //   exist (tried with pal5m.asc).  fix plx.
    // sort(&contourLevels, &contourLevels + numContourDepths);

    // File path variables
    std::string outputDataFilePath = "data/", outputDataFileType = ".dat",
           bathymetryTitle = "Topography", habitatTitle = "Habitat",
           goodnessTitle = "Goodness",
           coverageTitle = "Acoustic Coverage",
           bathymetryFilePath = outputDataFilePath + bathymetryTitle +
                                outputDataFileType,
           habitatFilePath    = outputDataFilePath + habitatTitle +
                                outputDataFileType,
           goodnessFilePath   = outputDataFilePath + goodnessTitle +
                                outputDataFileType,
           coverageFilePath   = outputDataFilePath + coverageTitle +
                                outputDataFileType;

    Grid bGrid(rowDist + 2 * border, colDist + 2 * border, "Behavior");
    Grid gGrid(rowDist + 2 * border, colDist + 2 * border, "Goodness");
    Grid tGrid(rowDist + 2 * border, colDist + 2 * border, "Topography");
    Grid cGrid(rowDist + 2 * border, colDist + 2 * border, "Coverage");

    Eigen::MatrixXd suppressionReference;
    Eigen::MatrixXd distanceGradient;
    Eigen::MatrixXd detectionGradient;
    distanceGradient.resize(sensorDetectionDiameter, sensorDetectionDiameter);
    distanceGradient.setConstant(0);
    detectionGradient.resize(sensorDetectionDiameter, sensorDetectionDiameter);
    detectionGradient.setConstant(0);
    // Create a gradient of distances to avoid redundant computation
    makeDistGradient(&distanceGradient, sensorDetectionRange);
    // Create a gradient of probability of detection (due to sensorRange) to
    // avoid redundant computation
    makeDetectionGradient(&detectionGradient, & distanceGradient,
                   sensorPeakDetectionProbability, SDofSensorDetectionRange);

    // Fetch or simulate topography
    std::cout << "Getting topography...";
    if (simulateBathy) {
        // Simulate topography
        simulatetopographyGrid(&tGrid, rowDist, colDist);
    } else {
        // Fetch actual topography
        getBathy(&tGrid, acousticParams["inputFile"],
                 acousticParams["inputFileType"], size_t(startRow),
                 size_t(startCol), size_t(rowDist), size_t(colDist),
                 acousticParams["seriesName"], acousticParams["timestamp"]);
    }
    std::cout << bGrid.data;
    // Fill in Behavior Grid
    std::cout << "\nGetting Behavior...";
    populateBehaviorGrid(&tGrid, &bGrid, bias, cellSize, ousdx, ousdy, oucor, mux,
                         muy, fishmodel);

    // Initalize the Coverage Grid
    cGrid.data.block(border, border, rowDist, colDist).setConstant(1);

    // Mr. Gaeta, START THE CLOCK!
    vizBegin = clock();
    std::cout << "\nGetting Goodness...\nBias: " << bias << "\n";
    // Calculate good sensor locations
    calculateGoodnessGrid(&tGrid, &bGrid, &gGrid, &suppressionReference,
                        &detectionGradient, &distanceGradient, bias,
                        sensorDetectionRange, border, border,
                        rowDist, colDist);
    vizEnd = clock();
    goodnessGridComputationTime =
            static_cast<double>(end - begin) / CLOCKS_PER_SEC;
    std::cout << "Copying goodness grid...\n";
    Grid UGGrid(&gGrid, "Unsuppressed Goodness");

    // Find optimal placements
    std::cout << "\nPlacing Sensors...\n";
    Eigen::MatrixXd bestSensors;
    bestSensors.resize(numSensorsToPlace, 4);


    //============================
    gGrid.name = "x1";
    Graph x1Graph = Graph(&gGrid);
    x1Graph.writeMat();

    // Grab the top n sensor r,c locations and recovery rates.
    selectTopSensorLocations(&tGrid, &bGrid, &gGrid, &UGGrid,
                   &bestSensors, &userSensorList, &suppressionReference,
                   &detectionGradient, &distanceGradient,
                   numSensorsToPlace,
                   sensorDetectionRange, bias, suppressionRangeFactor,
                   suppressionDiameter, sensorPeakDetectionProbability,
                   SDofSensorDetectionRange, acousticParams["timestamp"]);

    gGrid.name = "x2";
    Graph x2Graph = Graph(&gGrid);
    x2Graph.writeMat();
    std::cout << bestSensors << "\n";

    std::cout << "Computing Statistics...\n";
    getStats(&UGGrid, &gGrid, &bestSensors, sensorDetectionRange, &networkSparsity,
              &absRecoveryRate, &uniqueRecoveryRate, &cGrid);

    gGrid.name = "x3";
    Graph x3Graph = Graph(&gGrid);
    x3Graph.writeMat();
    gGrid.name = "Goodness";
    // Generate graphs
    std::cout<< "\nWriting Graphs...";
    Graph gGraph = Graph(&UGGrid);
    Graph tGraph = Graph(&tGrid);
    Graph bGraph = Graph(&bGrid);
    Graph cGraph = Graph(&cGrid);
    try {
        // Print the matrix & data files for Topography Grid
        tGraph.writeMat();
        tGraph.writeDat();
        // Print the contour file used by all graphs.
        //     (Do this just once as it takes a loooong time).
        tGraph.printContourFile(&contourLevels);
        // Graph the Topography Grid with contour lines.
        bool plotSensors = true;
        tGraph.printContourGraph(width, height, &contourLevels, plotSensors,
                                 &userSensorList, &bestSensors,
                                 numProjectedSensors, false);

        // Print the matrix & data files for Bathymetry Grid
        bGraph.writeMat();
        bGraph.writeDat();
        // Graph Behavior Grid with contour lines.
        bGraph.printContourGraph(width, height, &contourLevels, plotSensors,
                                 &userSensorList, &bestSensors,
                                 numProjectedSensors, false);

        // Print the matrix & data files for Goodness Grid
        gGraph.writeMat();
        gGraph.writeDat();
        // Graph Goodness Grid with contour lines.
        gGraph.printContourGraph(width, height, &contourLevels, plotSensors,
                                 &userSensorList, &bestSensors,
                                 numProjectedSensors, false);

        // Print the matrix & data files for Goodness Grid
        cGraph.writeMat();
        cGraph.writeDat();
        // Graph Goodness Grid with contour lines.
        cGraph.printContourGraph(width, height, &contourLevels, plotSensors,
                                 &userSensorList, &bestSensors,
                                 numProjectedSensors, false);
    } catch (int e) {
        std::cout << "Error:" << e << "\n";
        return 0;
    }
    end = clock();
    goodnessGridComputationTime =
            static_cast<double>(vizEnd - vizBegin) / CLOCKS_PER_SEC;
    std::cout << "\nVisibility calculation took " <<
            goodnessGridComputationTime << " s";
    totalComputationTime = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
    std::cout << "\nEntire Run took " << totalComputationTime << " s";

    return 0;
}
예제 #2
0
int main(int argc, char *argv[]) {

	namespace po = boost::program_options;

	char * chTraxDir = getenv("TRAX_DIR");
	if ( chTraxDir == nullptr ) {
		std::cout << "TRAX_DIR not set" << std::endl;
		exit(1);
	}
	g_traxDir = chTraxDir;

	ExecutionParameters exec;
	EventDataLoadingParameters loader;
	GridConfig grid;

	std::string testSuiteFile;

	po::options_description cLoader("Config File: Event Data Loading Options");
	cLoader.add_options()
		("data.edSrc", po::value<std::string>(&loader.eventDataFile), "event database")
		("data.skipEvents", po::value<uint>(&loader.skipEvents)->default_value(0), "events to skip, default: 0")
		("data.maxEvents", po::value<int>(&loader.maxEvents)->default_value(1), "number of events to process, all events: -1")
		("data.minPt", po::value<float>(&loader.minPt)->default_value(1.0), "MC data only: minimum track Pt")
		("data.tracks", po::value<int>(&loader.maxTracks)->default_value(-1), "MC data only: number of valid tracks to load, all tracks: -1")
		("data.onlyTracks", po::value<bool>(&loader.onlyTracks)->default_value(true), "MC data only: load only tracks with hits in each layer")
		("data.eventLoader", po::value<std::string>(&loader.eventLoader)->default_value("standard"),
				"specify event loader: \"standard\" for PEventContainer (default); \"store\" for EventStore; \"repeated\" for performance measurements")
	;

	po::options_description cExec("Config File: Execution Options");
	cExec.add_options()
		("exec.threads", po::value<uint>(&exec.threads)->default_value(256), "number of work-items in one work-group")
		("exec.eventGrouping", po::value<uint>(&exec.eventGrouping)->default_value(1), "number of concurrently processed events")
		("exec.useCPU", po::value<bool>(&exec.useCPU)->default_value(false)->zero_tokens(), "force using CPU instead of GPGPU")
		("exec.iterations", po::value<uint>(&exec.iterations)->default_value(1), "number of iterations for performance evaluation")
		("exec.layerTripletConfig", po::value<std::string>(&exec.layerTripletConfigFile), "configuration file for layer triplets")
		("exec.layerTriplets", po::value<int>(&exec.layerTriplets)->default_value(-1), "number of layer triplets to load, default all: -1")
	;

	po::options_description cGrid("Config File: Grid Options");
	cGrid.add_options()
		("grid.nSectorsZ", po::value<uint>(&grid.nSectorsZ)->default_value(50), "number of grid cells in z dimension")
		("grid.nSectorsPhi", po::value<uint>(&grid.nSectorsPhi)->default_value(8), "number of grid cells in phi dimension")
	;

	po::options_description cCommandLine("Command Line Options");
	cCommandLine.add_options()
		("config", po::value<std::string>(&exec.configFile), "configuration file")
		("help", "produce help message")
		("silent", "supress all messages from TripletFinder")
		("verbose", "elaborate information")
		("prolix", "prolix output -- degrades performance as data is transferred from device")
		("live", "live output -- degrades performance")
		("cpu", "force running on cpu")
		("testSuite", po::value<std::string>(&testSuiteFile), "specify a file defining test cases to be run")
	;

	po::variables_map vm;
	po::store(po::parse_command_line(argc,argv,cCommandLine), vm);
	po::notify(vm);

	if(vm.count("help")){
		std::cout << cCommandLine << cExec << cGrid << cLoader << std::endl;
		return 1;
	}

	if(vm.count("config")){
		ifstream ifs(g_traxDir + "/configs/" + getFilename(exec.configFile));
		if (!ifs)
		{
			cerr << "can not open config file: " << exec.configFile << "\n";
			return 0;
		}
		else
		{
			po::options_description cConfigFile;
			cConfigFile.add(cLoader);
			cConfigFile.add(cExec);
			cConfigFile.add(cGrid);
			store(parse_config_file(ifs, cConfigFile), vm);
			notify(vm);
			ifs.close();
		}
	} else {
		cerr << "No config file specified!" <<std::endl;
		return 1;
	}

	//define verbosity level
	exec.verbosity = Logger::cNORMAL;
	if(vm.count("silent"))
		exec.verbosity = Logger::cSILENT;
	if(vm.count("verbose"))
		exec.verbosity = Logger::cVERBOSE;
	if(vm.count("prolix"))
		exec.verbosity = Logger::cPROLIX;
	if(vm.count("live"))
		exec.verbosity = Logger::cLIVE;
	if(vm.count("live") && vm.count("prolix"))
		exec.verbosity = Logger::cLIVEPROLIX;

	//check for cpu
	if(vm.count("cpu"))
		exec.useCPU = true;

	typedef std::pair<ExecutionParameters, EventDataLoadingParameters> tExecution;
	std::vector<tExecution> executions;

	//****************************************
	if(vm.count("testSuite")){

		ifstream ifs(g_traxDir + "/configs/" + getFilename(testSuiteFile));
		if (!ifs)
		{
			cerr << "can not open testSuite file: " << testSuiteFile << "\n";
			return 0;
		}
		else
		{
			std::vector<uint> threads;
			std::vector<uint> events;
			std::vector<uint> tracks;

			po::options_description cTestSuite;
			cTestSuite.add_options()
				("threads", po::value<std::vector<uint> >(&threads)->multitoken(), "work-group size")
				("tracks", po::value<std::vector<uint> >(&tracks)->multitoken(), "tracks to load")
				("eventGrouping", po::value<std::vector<uint> >(&events)->multitoken(), "events to process concurrently")
			;

			po::variables_map tests;
			po::store(parse_config_file(ifs, cTestSuite), tests);
			po::notify(tests);
			ifs.close();

			//add default values if necessary
			if(events.size() == 0)
				events.push_back(exec.eventGrouping);
			if(threads.size() == 0)
				threads.push_back(exec.threads);
			if(tracks.size() == 0)
				tracks.push_back(loader.maxTracks);

			//add test cases
			for(uint e : events){
				for(uint t : threads){
					for(uint n : tracks){

						ExecutionParameters ep(exec); //clone default
						EventDataLoadingParameters lp(loader);

						ep.threads = t;
						ep.eventGrouping = e; lp.maxEvents = e;
						lp.maxTracks = n;

						executions.push_back(std::make_pair(ep, lp));

					}
				}
			}
		}
	} else {
		executions.push_back(std::make_pair(exec, loader));
	}
	//************************************

	//**********************************

	//set up logger verbosity
	Logger::getInstance().setLogLevel(exec.verbosity);
	clever::context * contx = createContext(exec);

	RuntimeRecords runtimeRecords;
	PhysicsRecords physicsRecords;
	for(uint e = 0; e < executions.size();++e){ //standard case: only 1
		LLOG << "Experiment " << e << "/" << executions.size() << ": " << std::endl;
		LLOG << executions[e].first << " " << executions[e].second << std::endl;
		for(uint i = 0; i < exec.iterations; ++i){
			LLOG << i+1 << "  " << std::flush;
			auto res = buildTriplets(executions[e].first, executions[e].second, grid, contx);

			contx->clearAllBuffers();
			contx->clearPerfCounters();

			runtimeRecords.merge(res.first);
			physicsRecords.merge(res.second);
		}
		LLOG << std::endl;
	}

	delete contx;
	//**********************************

	runtimeRecords.logPrint();

	std::stringstream outputFileRuntime;
	outputFileRuntime << g_traxDir << "/runtime/" << "runtime." <<  getFilename(exec.configFile) << (testSuiteFile != "" ? "." : "") << getFilename(testSuiteFile) << (exec.useCPU ? ".cpu" : ".gpu") << ".csv";

	std::ofstream runtimeRecordsFile(outputFileRuntime.str(), std::ios::trunc);
	runtimeRecordsFile << runtimeRecords.csvDump();
	runtimeRecordsFile.close();

	std::stringstream outputFilePhysics;
	outputFilePhysics << g_traxDir << "/physics/" << "physics." << getFilename(exec.configFile) << ".csv";
	std::stringstream outputDirPhysics;
	outputDirPhysics << g_traxDir << "/physics/" << getFilename(exec.configFile);

	boost::filesystem::create_directories(outputDirPhysics.str());

	std::ofstream physicsRecordsFile(outputFilePhysics.str(), std::ios::trunc);
	physicsRecordsFile << physicsRecords.csvDump(outputDirPhysics.str());
	physicsRecordsFile.close();

	std::cout << Logger::getInstance();

}
예제 #3
0
void Level::initialize(ValeGame *gamePtr)
{
	gamePointer = gamePtr;
	graphics = gamePtr->getGraphics();
	input = gamePtr->getInput();

	srand(time(NULL));

	//fonts
    quickCD.initialize(graphics, hudNS::COOLDOWN_SIZE, false, false, hudNS::FONT);
    quickCD.setFontColor(hudNS::FONT_COLOR);
	focusCD.initialize(graphics, hudNS::COOLDOWN_SIZE, false, false, hudNS::FONT);
	focusCD.setFontColor(hudNS::FONT_COLOR);
	fleetfeetCD.initialize(graphics, hudNS::COOLDOWN_SIZE, false, false, hudNS::FONT);
	fleetfeetCD.setFontColor(hudNS::FONT_COLOR);
	scoreText.initialize(graphics, 64, false, false, hudNS::FONT);
	scoreText.setFontColor(SETCOLOR_ARGB(255, 78, 162, 241));

	//textures
	wardenTexture.initialize(graphics, WARDEN_IMAGE);
	projectileTextures.initialize(graphics, PROJECTILE_IMAGE);
	focusBarFillTexture.initialize(graphics, FOCUS_BAR_FILL); 
	focusBarBGTexture.initialize(graphics, FOCUS_BAR_BG); 
	focusBarBGMuseTexture.initialize(graphics, FOCUS_BAR_BG_MUSE); 
	heartHUDTexture.initialize(graphics, HEART_HUD);
	heartTexture.initialize(graphics, HEART_ICON);
	spawnPointTexture.initialize(graphics,SPAWNER_IMAGE);

	//ability textures
	for(int i = 0; i < wardenNS::NUM_BOWS; i++)
	{
		bowTexture[i].initialize(graphics, BOW_ICON[i]);
		quickShotAbilityTexture[i].initialize(graphics, QUICKSHOT_ICON[i]);
		focusShotAbilityTexture[i].initialize(graphics, FOCUSSHOT_ICON[i]);
	}
	fleetFeetAbilityTexture.initialize(graphics, FLEETFEET_ICON);


	// Collision detection
	// Compute grid dimensions from the map size divided by grid dimension size
	float dX = (float)((width * tileSize)/GRID_CELL_DIMENSIONS);
	gridW = (int)ceil(dX);
	float dY = (float)((height * tileSize)/GRID_CELL_DIMENSIONS);
	gridH = (int)ceil(dY);

	// Instantiate the grid
	collision = cGrid(gridW, gridH, GRID_CELL_DIMENSIONS, &score);

	//particle system bs
	ps.initialize(graphics, L"..\\..\\Textures\\Particles\\smoke_hardedge.tga");
	ps.setEmitterShape(EMITTER_SHAPE_NONE);
	ps.setEmitterType(EMITTER_TYPE_DEFAULT);
	D3DXVECTOR2 tempPos(-100.0f, -100.0f);
	ps.setPosition(tempPos);
	
	particleSystems.resize(5);
	for(int i = 0; i < 5; i++)
	{
		particleSystems[i].initialize(graphics, L"..\\..\\Textures\\Particles\\smoke_hardedge.tga");
		particleSystems[i].setEmitterShape(EMITTER_SHAPE_NONE);
		particleSystems[i].setEmitterType(EMITTER_TYPE_DEFAULT);
		D3DXVECTOR2 tempPos(-100.0f, -100.0f);
		particleSystems[i].setPosition(tempPos);
	}
	lastUsedParticleSystem = 4;

	//warden
	warden.initialize(gamePtr, 32, 32, 1, &wardenTexture, &projectileTextures, &projectileTextures);
	D3DXVECTOR2 tmp(hudNS::SPAWN_X, hudNS::SPAWN_Y);
	warden.setPosition(tmp);
	score = 0;

	//Enemies
	risenManager.init(&score);
	risenSpawner.initialize(gamePtr,32,32,1,&spawnPointTexture,&risenManager.risen,&warden,tiles);
	risenSpawner.setPosition(tmp);

	addTimedSpawn(gamePtr,Risen::WAR,30.0,D3DXVECTOR2(2000.0f,1500.0f),400000);

	std::vector<Risen::types> hello1;
	std::vector<int> hello2;
	hello1.push_back(Risen::WARLOCK);
	hello1.push_back(Risen::ARCHER);
	hello1.push_back(Risen::HOUND);
	hello2.push_back(2);
	hello2.push_back(3);
	hello2.push_back(1);
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(750.0f,3200.0f),400000);
	
	hello1.clear();
	hello2.clear();
	hello1.push_back(Risen::HOUND);
	hello2.push_back(1);
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(1500.0f,2750.0f),400000);

	hello1.clear();
	hello2.clear();

	hello1.push_back(Risen::WAR);
	hello1.push_back(Risen::ARCHER);
	hello2.push_back(1);
	hello2.push_back(1);
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(3300.0f,1000.0f),300000);

	hello1.clear();
	hello2.clear();

	hello1.push_back(Risen::WAR);
	hello2.push_back(1);
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(2350.0f,785.0f),320000);

	hello2[0] = 2;
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(2430.0f,175.0f),120000);

	hello1.push_back(Risen::WARLOCK);
	hello2.push_back(1);
	hello2[0] = 1;
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(3650.0f,1900.0f),250000);
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(3700.0f,2000.0f),200000);
	hello1[1] = Risen::WAR;
	addStaticSpawn(gamePtr,hello1,hello2,D3DXVECTOR2(3700.0f,1800.0f),250000);

	//equipment
	addBow(20, 2, SPLIT);
	addBow(19, 21, MUSE);

	//Hud
	scoreRect.left = 50.0f; scoreRect.top = 50.0f; scoreRect.bottom = 150.0f; scoreRect.right = 250.0f;
	//focus bar
	focusBarFill.initialize(graphics, &focusBarFillTexture, 128, 128, 0, 0, 1.0f, graphicsNS::WHITE);
	focusBarBG.initialize(graphics,128, 128, 1, &focusBarBGTexture);
	focusBarBGMuse.initialize(graphics, 128, 128, 1, &focusBarBGMuseTexture);

	for(int i = 0; i < 4; i++)
	{
		heartHUD[i].initialize(graphics, 32, 32, 1, &heartHUDTexture);
		heartHUD[i].setX(hudNS::HEART_X + i*32);
		heartHUD[i].setY(hudNS::HEART_Y);
	}

	//abilities 
	for(int i = 0; i < wardenNS::NUM_BOWS; i++)
	{
		quickShotAbility[i].initialize(graphics, hudNS::ABILITY_ICON_SIZE, hudNS::ABILITY_ICON_SIZE, 1, &quickShotAbilityTexture[i]);

		quickShotAbility[i].setX(hudNS::QUICK_ICON_X);
		quickShotAbility[i].setY(hudNS::ABILITY_ICON_Y);

		focusShotAbility[i].initialize(graphics, hudNS::ABILITY_ICON_SIZE, hudNS::ABILITY_ICON_SIZE, 1, &focusShotAbilityTexture[i]);		

		focusShotAbility[i].setX(hudNS::FOCUS_ICON_X);
		focusShotAbility[i].setY(hudNS::ABILITY_ICON_Y);
	}


	fleetFeetAbility.initialize(graphics, hudNS::ABILITY_ICON_SIZE, hudNS::ABILITY_ICON_SIZE, 1, &fleetFeetAbilityTexture);
	fleetFeetAbility.setX(hudNS::FLEET_ICON_X);
	fleetFeetAbility.setY(hudNS::ABILITY_ICON_Y);
}