#include "dxstdafx.h"
#include ".\gamesceneloader.h"
#include "GameManager.h"
#include "UserPlayer.h"
#include "Weapon.h"
#include "SimpleWeapon.h"
#include "SimpleBullet.h"
#include "Terrain.h"
#include "HUD.h"
#include "Ocean.h"
#include "SkyBox.h"
#include "Object3d.h"
#include "NxActorDesc.h"
#include "NxMaterialDesc.h"
#include "NxMaterial.h"
#include "Goodie.h"
#include "UserContactReport.h"
#include "UniversalWeapon.h"
#include "ParticleEmitter.h"
#include "ParticleGroup.h"
#include "Sprite.h"

GameSceneLoader::GameSceneLoader(void)
{
	
	//XML Stuff
	::CoInitialize(NULL);

	HRESULT hr = sceneDomDocument.CreateInstance(MSXML::CLSID_DOMDocument);
	if (FAILED(hr))	{
		//MessageBox(NULL,"Unable to create XML instance!", "Wuermer DEBUG",MB_OK|MB_ICONQUESTION);
		this->scene->manager->printToConsole("Unable to create XML instance!");
		exit(0);
	}
}

GameSceneLoader::~GameSceneLoader(void)
{
}

bool GameSceneLoader::loadGameScene(GameScene &_scene, std::string filename, GameManager *_manager) { 
	this->scene = &_scene;
	// specify xml file name
	variant_t vResult;
	
	vResult = sceneDomDocument->load(filename.c_str());
	if (((bool)vResult) == TRUE) {
		sceneDocRoot = sceneDomDocument->documentElement;
	} else {
		this->scene->manager->printToConsole(filename);
		this->scene->manager->printToConsole("Loading GameScene failed!");
		MessageBox(NULL, L"Maybe the file is not a valid xml!", L"Error loading .xml file!", MB_ICONERROR);
		return false;
	}
	
	//Clear existing gamescene
	/*if (this->loadAgain) {
        this->scene->clearScene();
	} else {
		this->loadAgain = true;
	}*/

	//BuildGame
	_bstr_t tmpName("name");
	_bstr_t tmpMode("mode");
	_bstr_t tmpTime("time");
	_bstr_t tmpSun("sun");
	_bstr_t	tmpDimension("dimension");
	_bstr_t tmpTerrain("terrain");
	_bstr_t tmpOcean("ocean");
	_bstr_t tmpSkyBox("skybox");
	_bstr_t tmpBullet("bullet");
	_bstr_t tmpWeapon("weapon");
	_bstr_t tmpPlayer("player");
	_bstr_t tmpGoodies("goodies");
	_bstr_t tmpPMaterial("pmaterial");
	_bstr_t tmpHud("hud");
	_bstr_t tmpParticleEmitter("particleEmitter");
	_bstr_t tmpSoundFile("soundfile");
	_bstr_t tmpSoundVolume("soundvolume");
	_bstr_t tmpEnvObject("envObject");
	_bstr_t tmpDescription("description");
	_bstr_t tmpDescriptionDuration("descduration");
	_bstr_t tmpMaxEnemyCount("maxenemycount");
	std::string description;
	bool descSet = false;
	float descTime = 3;
	int maxEnemyCount = 1;
	Vector dimension;

	//NOTE: this is a hack to ensure that the scene has constant size (==>watermap!)
	dimension.addXYZ(320, 40, 320);
	this->scene->setWidth(dimension.x);
	this->scene->setHeight(dimension.y);
	this->scene->setDepth(dimension.z);

	for (MSXML::IXMLDOMNodePtr pChild = sceneDocRoot->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpName) {
				this->scene->gameName = pChild->firstChild->text;			//GameScene Name
			} else if(pChild->nodeName == tmpMode) {
				this->scene->gameMode = atoi(pChild->firstChild->text);		//Game Mode
			} else if(pChild->nodeName == tmpTime) {
				this->scene->gameDuration = (float)atoi(pChild->firstChild->text);	//Game Time
			} /*else if (pChild->nodeName == tmpDimension) {
				dimension = this->tracePosition(pChild);					//Dimension of level
				this->scene->setWidth(dimension.x);
				this->scene->setHeight(dimension.y);
				this->scene->setDepth(dimension.z);
			}*/ else if(pChild->nodeName == tmpTerrain) {
				this->traceTerrain(pChild);									//Terrain
			} else if(pChild->nodeName == tmpOcean) {
				this->traceOcean(pChild);									//Ocean  //TODO EINFUEGEN!!!
				this->scene->manager->printToConsole("Uncomment this->traceOcean(...) in GameSceneLoader!!");
			} else if(pChild->nodeName == tmpSkyBox) {
				this->traceSkyBox(pChild);									//SkyBox
			} else if(pChild->nodeName == tmpBullet) {
				this->traceBullet(pChild);									//Bullet
			} else if(pChild->nodeName == tmpWeapon) {
				this->traceWeapon(pChild);									//Weapon
			} else if(pChild->nodeName == tmpPlayer) {
				this->tracePlayer(pChild);									//Player
			} else if(pChild->nodeName == tmpGoodies) {
				this->traceGoodies(pChild);									//Goodies
			} else if(pChild->nodeName == tmpSun) {
				this->traceSun(pChild);										//Sun
			} else if(pChild->nodeName == tmpHud) {
				this->traceHud(pChild);										//HUD
			} else if(pChild->nodeName == tmpParticleEmitter) {
				this->traceParticleEmitter(pChild);							//ParticleEmitter
			} else if(pChild->nodeName == tmpSoundFile) {
				std::string soundFile = pChild->firstChild->text;
				this->scene->setBackgroundSound(soundFile);					//BackgroundSound
			} else if(pChild->nodeName == tmpSoundVolume) {
				this->scene->setBackgroundSoundVolume((FLOAT)atof(pChild->firstChild->text));	//SoundVolume
			} else if(pChild->nodeName == tmpEnvObject) {
				this->traceEnvironmentObject(pChild);						//Environment Object
			} else if(pChild->nodeName == tmpPMaterial) {
				this->tracePMaterial(pChild);
			} else if(pChild->nodeName == tmpDescription) {
				description = pChild->firstChild->text;
				descSet = true;
			} else if(pChild->nodeName == tmpDescriptionDuration) {
				descTime = (FLOAT) atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpMaxEnemyCount) {
				maxEnemyCount = (INT) atoi(pChild->firstChild->text);
				this->scene->setMaxEnemyCount(maxEnemyCount);
			}
		}
	}

	if(descSet) {
		this->scene->setChallengeDescription(description, descTime);
	}

	return true;
}

void GameSceneLoader::traceSun(MSXML::IXMLDOMNodePtr sunNode) {
	Vector direction;
	_bstr_t tmpDirection("direction");

	for (MSXML::IXMLDOMNodePtr pChild = sunNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpDirection) {
				direction = tracePosition(pChild);
			}
		}
	}
	direction = direction*(-1); //Use direction vector
	this->scene->setLight(direction);
}

Vector GameSceneLoader::tracePosition(MSXML::IXMLDOMNodePtr positionNode) {
	_bstr_t tmpX("x");
	_bstr_t tmpY("y");
	_bstr_t tmpZ("z");
	Vector position;
	for (MSXML::IXMLDOMNodePtr pChild = positionNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpX) {
				position.x = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpY) {
				position.y = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpZ) {
				position.z = (FLOAT)atof(pChild->firstChild->text);
			}
		}
	}
	return position;
}

void GameSceneLoader::traceBullet(MSXML::IXMLDOMNodePtr bulletNode) {
	/*<bullet>
		<type>0</type>
		<speed>4000</speed>
		<impactForce>150000</impactForce>
	</bullet>*/
	_bstr_t tmpType("type");
	_bstr_t tmpSpeed("speed");
	_bstr_t tmpImpactForce("impactForce");
	_bstr_t tmpXFile("xfile");
	_bstr_t tmpFlySound("flySound");
	_bstr_t tmpImpactSound("impactSound");
	_bstr_t tmpParticleEmitter("particleEmitter");

	//_bstr_t tmpPActor("pactor");
	//MSXML::IXMLDOMNodePtr pActorNode;
	//bool pActorInside = false;
	int type=0;
	float speed=0;
	float impactForce=0;
	std::string flySound = "";
	std::string impactSound = "";
	std::string xfile = "";
	std::vector<ParticleEmitter *> partEmitt;
	for (MSXML::IXMLDOMNodePtr pChild = bulletNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpSpeed) {
				speed = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpImpactForce) {
				impactForce = (FLOAT)atof(pChild->firstChild->text);  //float between 0...16!!
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpFlySound) {
				flySound = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpImpactSound) {
				impactSound = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpParticleEmitter) { //Particle Emitter for Bullet!
				ParticleEmitter* tempEmitt = this->traceParticleEmitter(pChild);
				partEmitt.push_back(tempEmitt);
			}
			/*else if(pChild->nodeName == tmpPActor) {
				pActorNode = pChild;
				pActorInside = true;
			}*/
		}
	}
	if(type<3) {
		SimpleBullet *bullet = (SimpleBullet *) this->scene->createReferenceNode(this->scene->NODE_SIMPLEBULLET, true); 
		bullet->setBulletType(type);
		if(speed!=0)
			bullet->setSpeed(speed);
		if(impactForce!=0)
			bullet->setImpactForce(impactForce);
		bullet->setXFile(xfile);
		bullet->setFlySound(flySound);
		bullet->setImpactSound(impactSound);
		for(UINT i = 0; i<partEmitt.size(); i++) {
			if(partEmitt[i] == NULL) {
				this->scene->manager->printToConsole("ist nullllllllllllllllllllllllllllllllll!");
			}
			bullet->addParticleEmitter(partEmitt[i]);
		}
	} //else if...

	/*Bullet *bullet = (Bullet *) this->scene->createReferenceNode(this->scene->NODE_BULLET, true); 
	bullet->setType(type);
	bullet->setSpeed(speed);
	bullet->setImpactForce(impactForce);
	bullet->setFilename(mdlObject.c_str());
	if(pActorInside)
		this->tracePActor(pActorNode, *bullet);*/
}

void GameSceneLoader::traceWeapon(MSXML::IXMLDOMNodePtr weaponNode) {
	/*	<weapon>
		<type>0</type>
		<bulletType>0</bulletType>
		<reboundForce>500</reboundForce>
		..
		..
		..
	</weapon>*/

	_bstr_t tmpType("type");
	_bstr_t tmpBulletType("bulletType");
	_bstr_t tmpReboundForce("reboundForce");
	_bstr_t tmpIdleSound("idleSound");
	_bstr_t tmpPreloadTime("preloadTime");
	_bstr_t tmpPreloadSound("preloadSound");
	_bstr_t tmpFireTime("fireTime");
	_bstr_t tmpFireSound("fireSound");
	_bstr_t tmpPostloadTime("postloadTime");
	_bstr_t tmpPostloadSound("postloadSound");
	_bstr_t tmpEmptySound("emptySound");
	
	_bstr_t tmpXFile("xfile");

	int type=0;
	int bulletType=0;
	float reboundForce=0;
	std::string idleSound;
	float preloadTime=0;
	std::string preloadSound;
	float fireTime=0;
	std::string fireSound;
	float postloadTime=0;
	std::string postloadSound;
	std::string emptySound;
	std::string xfile;
	for (MSXML::IXMLDOMNodePtr pChild = weaponNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);				//WeaponType
			} else if(pChild->nodeName == tmpBulletType) {
				bulletType = atoi(pChild->firstChild->text);		//BulletType
			} else if(pChild->nodeName == tmpReboundForce) {
				reboundForce = (FLOAT)atof(pChild->firstChild->text);		//ReboundForce
			} else if(pChild->nodeName == tmpIdleSound) {
				idleSound = pChild->firstChild->text;				//IdleSound
			} else if(pChild->nodeName == tmpPreloadTime) {
				preloadTime = (FLOAT)atof(pChild->firstChild->text);		//PreloadTime
			} else if(pChild->nodeName == tmpPreloadSound) {	
				preloadSound = pChild->firstChild->text;			//PreloadSound
			} else if(pChild->nodeName == tmpFireTime) {
				fireTime = (FLOAT)atof(pChild->firstChild->text);			//FireTime
			} else if(pChild->nodeName == tmpFireSound) {
				fireSound = pChild->firstChild->text;				//FireSound
			} else if(pChild->nodeName == tmpPostloadTime) {
				postloadTime = (FLOAT)atof(pChild->firstChild->text);		//PostloadTime
			} else if(pChild->nodeName == tmpPostloadSound) {
				postloadSound = pChild->firstChild->text;			//PostloadSound
			} else if(pChild->nodeName == tmpEmptySound) {
				emptySound = pChild->firstChild->text;				//EmptySound
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;					//XFile
			}
		}
	}
	if(type <= 4) { //All simpleWeapons
		SimpleWeapon *weapon = (SimpleWeapon *) this->scene->createReferenceNode(this->scene->NODE_SIMPLEWEAPON, true);
		weapon->setWeaponType(type);
	} else {		//Yet, only these Types are supported!
		UniversalWeapon *weapon = (UniversalWeapon*) this->scene->createReferenceNode(GameScene::NODE_UNIVERSALWEAPON, true);
		weapon->setWeaponType(type);
		weapon->setBulletType(bulletType);
		weapon->setReboundForce(reboundForce);
		weapon->setStateSound(Weapon::STATE_IDLE, idleSound);
		weapon->setStateTime(Weapon::STATE_PRELOAD, preloadTime);
		weapon->setStateSound(Weapon::STATE_PRELOAD, preloadSound);
		weapon->setStateTime(Weapon::STATE_FIRE, fireTime);
		weapon->setStateSound(Weapon::STATE_FIRE, fireSound);
		weapon->setStateTime(Weapon::STATE_POSTLOAD, postloadTime);
		weapon->setStateSound(Weapon::STATE_POSTLOAD, postloadSound);
		weapon->setStateSound(Weapon::STATE_EMPTY, emptySound);
		weapon->setXFile(xfile);
		weapon->setStandBy(true);
	}
	//else if...
	/*Weapon *weapon = (Weapon *) this->scene->createReferenceNode(this->scene->NODE_WEAPON, true);
	weapon->setType(type);
	weapon->setBulletType(bulletType);
	weapon->setReboundForce(reboundForce);
	weapon->setLeftWeapon(mdlObject.c_str());
	weapon->setRightWeapon(mdlObject.c_str());
	weapon->setReboundTime(reboundTime);
	weapon->setReloadTime(reloadTime);*/
}

void GameSceneLoader::tracePlayer(MSXML::IXMLDOMNodePtr playerNode) {
	Vector position;
	int type;
	int team = 0;
	std::string avatar = "";

	_bstr_t tmpType("type");
	_bstr_t tmpPosition("position");
	_bstr_t tmpWeapon("weapon");
	_bstr_t tmpTeam("team");
	_bstr_t tmpAvatar("xfile");

	bool aiPlayer = false;

	Player *player = NULL;
	for (MSXML::IXMLDOMNodePtr pChild = playerNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
				switch(type) {
					case 0:
						this->scene->manager->printToConsole("Creating UserPlayer");
						player = (Player *) this->scene->createNode(this->scene->NODE_USERPLAYER, false);
						break;
					case 1:
						this->scene->manager->printToConsole("Creating AIPlayer");
						player = (Player *) this->scene->createNode(this->scene->NODE_AIPLAYER, false);
						aiPlayer = true;
                        break;
				}
			} else if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
				player->initPlayer(position.x, position.y, position.z);
			} else if(pChild->nodeName == tmpWeapon) {
                this->addWeapon(pChild, *player);				
			} else if(pChild->nodeName == tmpTeam) {
				team = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAvatar) {
				avatar = pChild->firstChild->text;
				player->setAvatareFileName(avatar);
			}
		}
	}

	if(aiPlayer) {
		this->scene->enemyModel = avatar;
	}
	
	//player->initPlayer(position.x, position.y, position.z);
	player->setTeam(team);
	player->setActiveWeapon(0);
}

void GameSceneLoader::addWeapon(MSXML::IXMLDOMNodePtr playerWeaponNode, Player &player) {
	//Addweapon and munition
	/*<weapon>
		<type>0</type>
		<amount>100</amount>
	</weapon>*/
	_bstr_t tmpType("type");
	_bstr_t tmpAmount("amount");

	int type=0;
	int amount=0;
	
	for (MSXML::IXMLDOMNodePtr pChild = playerWeaponNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAmount) {
				amount = atoi(pChild->firstChild->text);
			}
		}
	}
	if(type<=4) {
		//this->scene->manager->printToConsole("   adding Weapon Type<=3");
		SimpleWeapon *weapon = (SimpleWeapon *) this->scene->createNode(this->scene->NODE_SIMPLEWEAPON, *player.schale, true);
		weapon->setWeaponType(type);
		weapon->addMunition(amount);
		weapon->initWeapon();
		player.addWeapon(*weapon);
		return;
	} else {
		player.addWeapon(*this->scene->cloneWeaponFromReference(type));
	}

	/*Weapon *refWeapon = NULL;

	//Find Reference Weapon
	for(unsigned int i=0;i<this->scene->refWeaponList.size();i++) {
		refWeapon = (Weapon *) this->scene->refWeaponList.at(i).get();
		if(refWeapon->getWeaponType()==type)
			break;
	}*/

	//Add Weapon to Player
	//Weapon *weapon = player.sMgr->createWeapon(*player.schale);
	/*Weapon *weapon = (Weapon *) this->scene->createNode(this->scene->NODE_WEAPON, *player.schale, true);
	weapon->setType(refWeapon->getType());
	weapon->setBulletType(refWeapon->getBulletType());
	weapon->setReboundForce(refWeapon->getReboundForceLength());
	weapon->setLeftWeapon(refWeapon->getLeftWeaponFilename());
	weapon->setRightWeapon(refWeapon->getRightWeaponFilename());
	weapon->setReboundTime(refWeapon->getReboundTime());
	weapon->setReloadTime(refWeapon->getReloadTime());
	weapon->initWeapon();
	player.addWeapon(*weapon);
	player.addMunition(refWeapon->getBulletType(), amount);*/


}

void GameSceneLoader::traceSkyBox(MSXML::IXMLDOMNodePtr skyBoxNode) {
	/*<skybox>
			<skyname>./media/sky.x</skyname>
	</skybox>*/
	
	_bstr_t tmpCube("xfile");
	/*_bstr_t tmpTexture0("skytexture0");
	_bstr_t tmpTexture1("skytexture1");
	_bstr_t tmpTexture2("skytexture2");
	_bstr_t tmpTexture3("skytexture3");
	_bstr_t tmpTexture4("skytexture4");
	_bstr_t tmpTexture5("skytexture5");
	_bstr_t tmpTexture6("skytexture6");
	_bstr_t tmpTexture7("skytexture7");
	_bstr_t tmpTexture8("skytexture8");*/

	std::string skyname;
	/*std::string texture0;
	std::string texture1;
	std::string texture2;
	std::string texture3;
	std::string texture4;
	std::string texture5;
	std::string texture6;
	std::string texture7;
	std::string texture8;*/
	
	std::string skyTexture;
	for (MSXML::IXMLDOMNodePtr pChild = skyBoxNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpCube) {
				skyname = pChild->firstChild->text;
			}
			/*if(pChild->nodeName == tmpTexture0) {
				texture0 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture1) {
				texture1 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture2) {
				texture2 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture3) {
				texture3 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture4) {
				texture4 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture5) {
				texture5 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture6) {
				texture6 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture7) {
				texture7 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture8) {
				texture8 = pChild->firstChild->text;
			}*/
		}
	}

	//SkyBox erzeugen & entsprechende Texture laden
	/*this->scene->createSkybox();*/

	SkyBox *skybox = (SkyBox *) this->scene->createNode(this->scene->NODE_SKYBOX, *this->scene->getRoot(), false);
	skybox->generateSkyBox(skyname);
	//skybox->generateSkyBox("./media/models/skybox1.x");

	/*this->scene->getSkybox()->setTexture0(texture0);
	this->scene->getSkybox()->setTexture1(texture1);
	this->scene->getSkybox()->setTexture2(texture2);
	this->scene->getSkybox()->setTexture3(texture3);
	this->scene->getSkybox()->setTexture4(texture4);
	this->scene->getSkybox()->setTexture5(texture5);
	this->scene->getSkybox()->setTexture6(texture6);
	this->scene->getSkybox()->setTexture7(texture7);
	this->scene->getSkybox()->setTexture8(texture8);


	this->scene->getSkybox()->generateSkybox(this->scene->getSunDirecetion());
	this->scene->getSkybox()->setSize(this->scene->getTerrain()->getSize());*/
}

void GameSceneLoader::traceTerrain(MSXML::IXMLDOMNodePtr terrainNode) {
	_bstr_t tmpHeightMap("heightmap");
	_bstr_t tmpTexture0("texture0");
	_bstr_t tmpTexture1("texture1");
	_bstr_t tmpTexture2("texture2");

	std::string heightMap;
	std::string texture0;
	std::string texture1;
	std::string texture2;
	for (MSXML::IXMLDOMNodePtr pChild = terrainNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpHeightMap) {
				heightMap = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture0) {
				texture0 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture1) {
				texture1 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture2) {
				texture2 = pChild->firstChild->text;
			} 
		}
	}

	Terrain *terrain = (Terrain *) this->scene->createNode(this->scene->NODE_TERRAIN, *this->scene->getRoot(), false);
	
	terrain->setTextures(texture0, texture1, texture2);
	terrain->generateTerrain(heightMap, 129, 129);
}

void GameSceneLoader::traceOcean(MSXML::IXMLDOMNodePtr oceanNode) {
	_bstr_t tmpTexture0("texture0");
	_bstr_t tmpTexture1("texture1");
	_bstr_t tmpWatermap("watermap");
	_bstr_t tmpShallowColorR("shallowColorR");
	_bstr_t tmpShallowColorG("shallowColorG");
	_bstr_t tmpShallowColorB("shallowColorB");
	_bstr_t tmpDeepColorR("deepColorR");
	_bstr_t tmpDeepColorG("deepColorG");
	_bstr_t tmpDeepColorB("deepColorB");
	
	std::string texture0;
	std::string texture1;
	std::string watermap;
	float shallowColor [] = {0.0f, 0.0f, 0.0f, 0.0f};
	float deepColor [] = {0.0f, 0.0f, 0.0f, 0.0f};
	
	for (MSXML::IXMLDOMNodePtr pChild = oceanNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpTexture0) {
				texture0 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture1) {
				texture1 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpShallowColorR) {
				shallowColor[0] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpShallowColorG) {
				shallowColor[1] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpShallowColorB) {
				shallowColor[2] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDeepColorR) {
				deepColor[0] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDeepColorG) {
				deepColor[1] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDeepColorB) {
				deepColor[2] = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpWatermap) {
				watermap = pChild->firstChild->text;
			}
		}
	}
	
	Ocean *ocean = (Ocean *) this->scene->createNode(this->scene->NODE_OCEAN, *this->scene->getRoot(), false);
	
	ocean->setTextures(texture0, texture1, watermap);
	ocean->generateOcean(deepColor, shallowColor);
}

void GameSceneLoader::traceGoodies(MSXML::IXMLDOMNodePtr goodiesNode) {
	/*<goodies>
		<healthpackage>
		</healthpackage>
		<weaponpackage>
		</weaponpackage>
		<amopackage>
		</amopackage>
	</goodies>*/
	_bstr_t tmpHealthPackage("healthpackage");
	_bstr_t tmpWeapon("weaponpackage");
	_bstr_t tmpAmo("amopackage");
	//_bstr_t tmpPActor("pactor");
	MSXML::IXMLDOMNodePtr pActorNode;
	bool pActorInside = false;

	
	for (MSXML::IXMLDOMNodePtr pChild = goodiesNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpHealthPackage) {
				traceHealthPackage(pChild);
			} else if(pChild->nodeName == tmpWeapon) {
				traceWeaponPackage(pChild);
			} else if(pChild->nodeName == tmpAmo) {
				traceAmoPackage(pChild);
			}/*  else if(pChild->nodeName == tmpAmo) {
				pActorNode = pChild;
				pActorInside = true;
			}*/
		}
	}
}

void GameSceneLoader::traceWeaponPackage(MSXML::IXMLDOMNodePtr weaponNode) {
	/*<weaponpackage>
		<position>
			<x>1200</x>
			<y>450</y>
			<z>1300</z>
		</position>
		<type>0</type>
		<amount>1000</amount>
		<arrivalTime>20000</arrivalTime>
	</weaponpackage>*/
	_bstr_t tmpPosition("position");
	_bstr_t tmpType("type");
	_bstr_t tmpAmount("amount");
	_bstr_t tmpArrivalTime("arrivaltime");
	_bstr_t tmpVariation("timevariation");
	_bstr_t tmpPhysic("pactor");
	_bstr_t tmpRenderer("renderer");
	_bstr_t tmpXFile("xfile");

	int type = 0;
	int amo = 0;
	float arrivalTime = 0;
	float arrivalVariation = 0;
	Vector position;
	MSXML::IXMLDOMNodePtr physicChild;
	bool hasPActor = false;
	MSXML::IXMLDOMNodePtr rendererChild;
	bool hasRenderer = false;
	std::string xfile;
	for (MSXML::IXMLDOMNodePtr pChild = weaponNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAmount) {
				amo = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpArrivalTime) {
				arrivalTime = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVariation) {
				arrivalVariation = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpPhysic) {
				physicChild = pChild;
				hasPActor = true;
			} else if(pChild->nodeName == tmpRenderer) {
				rendererChild = pChild;
				hasRenderer = true;
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;
			}
		}
	}
	//TODO zufallssachen machen, goodie registrieren
	/*if(position.x = 0 && position.y = 0 && position.z = 0) {
		//Generate random coodinates
		float w = this->scene->getWidth();
		float y = this->scene->getHeight();

	}*/
	//Register WeaponPackage in ChallengeManager!!
	//this->cMgr->registerWeaponPackage(position, type, amo, arrivalTime);
	//this->scene->registerWeaponPackage(position, type, amo, arrivalTime, arrivalVariation);
	Goodie* wp;
	if(!hasRenderer) {
		wp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, true);
	} else {
		wp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, false);
		this->traceRenderer(rendererChild, *wp);
	}
	wp->setXFile(xfile);
	wp->setPosition(position);
	wp->setGoodieType(wp->GOODIE_WEAPON);
	wp->setWeaponType(type);
	wp->setArmorAmount(amo);
	wp->setStandBy(true);
	wp->loadGoodieMesh();
	if(hasPActor) {
		this->tracePActor(physicChild, *wp);
		wp->setColDetGroup(UserContactReport::COLGROUP_GOODIE);
	}
	wp->init();
	this->scene->setTrigger(this->scene->TRIGGER_UNSETSTANDBY, wp, this->scene->getRandomTime(arrivalTime, arrivalVariation));
}

void GameSceneLoader::traceHealthPackage(MSXML::IXMLDOMNodePtr healthNode) {
	/*<healthpackage>
		<position>
			<x>300</x>
			<y>450</y>
			<z>900</z>
		</position>
		<healthamount>100</healthamount>
		<arrivalTime>20000</arrivalTime>
	</healthpackage>*/
	_bstr_t tmpPosition("position");
	_bstr_t tmpHealth("healthamount");
	_bstr_t tmpArrivaltime("arrivaltime");
	_bstr_t tmpVariation("timevariation");
	_bstr_t tmpPhysic("pactor");
	_bstr_t tmpRenderer("renderer");
	_bstr_t tmpXFile("xfile");

	Vector position;
	float health = 0;
	float arrivalTime = 0;
	float arrivalVariation = 0;
	MSXML::IXMLDOMNodePtr physicChild;
	bool hasPActor = false;
	MSXML::IXMLDOMNodePtr rendererChild;
	bool hasRenderer = false;
	std::string xfile = "";
	for (MSXML::IXMLDOMNodePtr pChild = healthNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpHealth) {
				health = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpArrivaltime) {
				arrivalTime = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVariation) {
				arrivalVariation = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpPhysic) {
				physicChild = pChild;
				hasPActor = true;
			} else if(pChild->nodeName == tmpRenderer) {
				rendererChild = pChild;
				hasRenderer = true;
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;
			}
		}
	}

	Goodie* hp;
	if(!hasRenderer) {
		hp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, true);
	} else {
		hp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, false);
		this->traceRenderer(rendererChild, *hp);
	}
	hp->setXFile(xfile);
	hp->setPosition(position);
	hp->setGoodieType(hp->GOODIE_HEALTH);
	hp->setHealthAmount(health);
	hp->setStandBy(true);
	hp->loadGoodieMesh();
	if(hasPActor) {
		this->tracePActor(physicChild, *hp);
		hp->setColDetGroup(UserContactReport::COLGROUP_GOODIE);
	}
	//if use phyics
	//hp->generatePhysicMesh(obj->COL_CONVEX);
	//hp->setBehaveAs(obj->RIGIDBODY);
	hp->init();
	this->scene->setTrigger(this->scene->TRIGGER_UNSETSTANDBY, hp, this->scene->getRandomTime(arrivalTime, arrivalVariation));


	//Register HealthPackage in ChallengeManager!!
	//TODO this->cMgr->registerHealthPackage(position, health, arrivalTime);
	//this->scene->registerHealthPackage(position, health, arrivalTime, arrivalVariation);
}

void GameSceneLoader::traceAmoPackage(MSXML::IXMLDOMNodePtr amoNode) {
	/*<amopackage>
		<position>
			<x>1300</x>
			<y>450</y>
			<z>1300</z>
		</position>
		<type>0</type>
		<amount>1000</amount>
		<arrivalTime>20000</arrivalTime>
	</amopackage>*/
	_bstr_t tmpPosition("position");
	_bstr_t tmpType("type");
	_bstr_t tmpAmount("amount");
	_bstr_t tmpArrivalTime("arrivaltime");
	_bstr_t tmpVariation("timevariation");
	_bstr_t tmpPhysic("pactor");
	_bstr_t tmpRenderer("renderer");
	_bstr_t tmpXFile("xfile");

	Vector position;
	int type = 0;
	int amount = 0;
	float arrivalTime = 0;
	float arrivalVariation = 0;
	MSXML::IXMLDOMNodePtr physicChild;
	bool hasPActor = false;
	MSXML::IXMLDOMNodePtr rendererChild;
	bool hasRenderer = false;
	std::string xfile = "";
	for (MSXML::IXMLDOMNodePtr pChild = amoNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAmount) {
				amount = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpArrivalTime) {
				arrivalTime = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVariation) {
				arrivalVariation = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpPhysic) {
				physicChild = pChild;
				hasPActor = true;
			} else if(pChild->nodeName == tmpRenderer) {
				rendererChild = pChild;
				hasRenderer = true;
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;
			}
		}
	}

	Goodie* mp;
	if(!hasRenderer) {
		mp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, true);
	} else {
		mp = (Goodie*) this->scene->createNode(this->scene->NODE_GOODIE, false);
		this->traceRenderer(rendererChild, *mp);
	}
	mp->setXFile(xfile);
	mp->setPosition(position);
	mp->setGoodieType(mp->GOODIE_AMO);
	mp->setWeaponType(type);
	mp->setArmorAmount(amount);
	mp->setStandBy(true);
	mp->loadGoodieMesh();
	if(hasPActor) {
		this->tracePActor(physicChild, *mp);
		mp->setColDetGroup(UserContactReport::COLGROUP_GOODIE);
	}
	mp->init();
	this->scene->setTrigger(this->scene->TRIGGER_UNSETSTANDBY, mp, this->scene->getRandomTime(arrivalTime, arrivalVariation));
}

void GameSceneLoader::traceHud(MSXML::IXMLDOMNodePtr terrainNode) {
	_bstr_t tmpCrosshair("crosshair");
	_bstr_t tmpCrosshairX("crosshairscaleX");
	_bstr_t tmpCrosshairY("crosshairscaleY");
	_bstr_t tmpRadar("radar");
	_bstr_t tmpRadarX("radarscaleX");
	_bstr_t tmpRadarY("radarscaleY");
	_bstr_t tmpRadarOffsetX("radaroffsetX");
	_bstr_t tmpRadarOffsetY("radaroffsetY");
	_bstr_t tmpUserPlayer("userplayerscale");
	_bstr_t tmpAIPlayer("aiplayerscale");
	_bstr_t tmpTexture0("texture0");
	_bstr_t tmpTexture1("texture1");
	_bstr_t tmpTexture2("texture2");
	_bstr_t tmpTexture3("texture3");
	_bstr_t tmpTexture4("texture4");
	
	

	std::string crosshair;
	float CrosshairScaleX = 1.0f;
	float CrosshairScaleY = 1.0f;
	std::string radar;
	float RadarScaleX = 1.0f;
	float RadarScaleY = 1.0f;
	float RadarOffsetX = 20.0f;
	float RadarOffsetY = 20.0f;
	float scaleUserPlayer = 1.0f;
	float scaleAIPlayer = 1.0f;
	std::string texture0;
	std::string texture1;
	std::string texture2;
	std::string texture3;
	std::string texture4;

	
	for (MSXML::IXMLDOMNodePtr pChild = terrainNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpCrosshair) {
				crosshair = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpCrosshairX) {
				CrosshairScaleX = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpCrosshairY) {
				CrosshairScaleY = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRadar) {
				radar = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpRadarX) {
				RadarScaleX = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRadarY) {
				RadarScaleY = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRadarOffsetX) {
				RadarOffsetX = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRadarOffsetY) {
				RadarOffsetY = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpUserPlayer) {
				scaleUserPlayer = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAIPlayer) {
				scaleAIPlayer = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpTexture0) {
				texture0 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture1) {
				texture1 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture2) {
				texture2 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture3) {
				texture3 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpTexture4) {
				texture4 = pChild->firstChild->text;
			} 
		}
	}

	//instanciate hud
	HUD *hud = (HUD*) this->scene->createNode(this->scene->NODE_HUD, *this->scene->getRoot(), false);
	
	hud->setCrosshair(crosshair, CrosshairScaleX, CrosshairScaleY);
	hud->setRadar(radar, RadarScaleX, RadarScaleY, RadarOffsetX, RadarOffsetY);
	hud->setTextures(texture0, texture1, texture2, texture3, texture4, scaleUserPlayer, scaleAIPlayer);
	hud->generateHUD();
}

void GameSceneLoader::tracePActor(MSXML::IXMLDOMNodePtr actorNode, Object3d &obj) {
	/*<pactor>
		<behaveas>0</behaveas>		0 - NORMAL, 1 - STATIC, 2 - KINEMATIC, 3 - RIGIDBODY
		<colmode>1</colmode>		0 - MESH, 1 - HEIGHTFIELD, 2 - CONVEX, 3 - PMAP
		<density>10.2</density>
		<material>index</material>
	 </pactor>*/
	_bstr_t tmpColMode("colmode");
	_bstr_t tmpBehaveAs("behaveas");
	_bstr_t tmpDensity("density");
	_bstr_t tmpMaterial("material");
	_bstr_t tmpColGroup("colgroup");
	
	int colmode = 0;
	int behaveas = 0;
	float density = 10;
	int material = 0;
	int colgroup = UserContactReport::COLGROUP_OTHER;

	for (MSXML::IXMLDOMNodePtr pChild = actorNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpColMode) {
				colmode = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpBehaveAs) {
				behaveas = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDensity) {
				density = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpMaterial) {
				material = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpColGroup) {
				colgroup = atoi(pChild->firstChild->text);
			}
		}
	}
	NxActorDesc* ad = obj.getActorDescriptor();
	ad->density = density;
	obj.getBodyDescriptor()->mass = 0;
	obj.generatePhysicMesh(colmode);
	obj.setBehaveAs(behaveas);
	obj.setColDetGroup(colgroup);
	obj.setPMaterial(this->scene->getPhysicMaterialId(material));
}

void GameSceneLoader::tracePMaterial(MSXML::IXMLDOMNodePtr materialNode) {
	/*<pmaterial>
		<materialid>0<materialid>
		<restitution>0.7</restitution>
		<staticfriction>0.5</staticfriction>
		<dynamicfriction>0.5</dynamicfriction>
	 </pmaterial>*/
	_bstr_t tmpMaterial("materialid");
	_bstr_t tmpRestitution("restitution");
	_bstr_t tmpStaticFriction("staticfriction");
	_bstr_t tmpDynamicFriction("dynamicfriction");
	
	int materialid = 0;
	float restitution = 0.7f;
	float staticFriction = 0.5f;
	float dynamicFriction = 0.5f;

	for (MSXML::IXMLDOMNodePtr pChild = materialNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpMaterial) {
				materialid = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRestitution) {
				restitution = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpStaticFriction) {
				staticFriction = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDynamicFriction) {
				dynamicFriction = (FLOAT)atof(pChild->firstChild->text);
			}
		}
	}
	NxMaterialDesc md;
	md.restitution = restitution;
	md.staticFriction = staticFriction;
	md.dynamicFriction = dynamicFriction;
	NxMaterial* m = this->scene->pScene->createMaterial(md);
	this->scene->connectMaterialIds(m->getMaterialIndex(), materialid);
}

void GameSceneLoader::traceRenderer(MSXML::IXMLDOMNodePtr rendererNode, Node &node)
{
	/*<renderer>
		<type>0</type>		0 - RAYTRACE
		....other renderer parameter....
	 </renderer>*/
	_bstr_t tmpType("type");
	
	int type = 0;

	for (MSXML::IXMLDOMNodePtr pChild = rendererNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpType) {
				type = atoi(pChild->firstChild->text);
			}
		}
	}
	switch(type) {
		case 0:		//RaytraceRenderer
			this->traceRaytraceRenderer(rendererNode, node);
			break;
		case 1:		//ParticleRenderer
			SPTR<Renderer> renderer(new ParticleRenderer);
			//ParticleRenderer *r = (ParticleRenderer*) renderer.get();
			this->scene->connectNodeAndRenderer(node, renderer);
            break;
	}
}

void GameSceneLoader::traceRaytraceRenderer(MSXML::IXMLDOMNodePtr rendererNode, Node &node)
{
	/*<renderer>
		<fresnel>1.0</fresnel>
		<refraction>0.95</refraction>
	 </renderer>*/
	_bstr_t tmpFresnel("fresnel");
	_bstr_t tmpRefraction("refraction");
	_bstr_t tmpIteration("iterations");
	
	float fresnel = 0;
	float refraction = 0;
	int nbIteration = 10;

	for (MSXML::IXMLDOMNodePtr pChild = rendererNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpFresnel) {
				fresnel = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRefraction) {
				refraction = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpIteration) {
				nbIteration = atoi(pChild->firstChild->text);
			}
		}
	}

	SPTR<Renderer> renderer(new RaytraceRenderer);
	RaytraceRenderer *r = (RaytraceRenderer*) renderer.get();
	r->setFresnelFactor(fresnel);
	r->setRefractionIndex(refraction);
	r->setNumberOfIterations(nbIteration);
	this->scene->connectNodeAndRenderer(node, renderer);
}

ParticleEmitter* GameSceneLoader::traceParticleEmitter(MSXML::IXMLDOMNodePtr emitterNode) {
	/*<position>
		<x>1000</x>
		<y>200</y>
		<z>1000);</z>
	</position>
	<rotation>
		<x>-90</x>
		<y>0</y>
		<z>0</z>
	</rotation>
	<dimension>
		<x>-20</x>
		<y>20</y>
		<z>0</z>
	</dimension>
	<velocity>600</velocity>
	<duration>10</duration>
	<horizontalDegree>0.2</horizontalDegree>
	<verticalDegree>0.2</verticalDegree>
	<rotationalDegree>
		<x>0</x>
		<y>0</y>
		<z>10</z>
	</rotationalDegree>
	<birthRate>100</birthRate>*/

	_bstr_t tmpPosition("position");
	_bstr_t tmpRotation("rotation");
	_bstr_t tmpDimension("dimension");
	_bstr_t tmpVelocity("velocity");
	_bstr_t tmpDuration("duration");
	_bstr_t tmpHDegree("horizontalDegree");
	_bstr_t tmpVDegree("verticalDegree");
	_bstr_t tmpRDegree("rotationalDegree");
	_bstr_t tmpBirthRate("birthRate");
	_bstr_t tmpSprite("sprite");
	_bstr_t tmpEnvObject("envObject");
	_bstr_t	tmpTimeToLive("timetolive");
	_bstr_t	tmpColGroup("colGroup");
	_bstr_t	tmpRenderer("renderer");
	_bstr_t tmpHeatHaze("heathaze");
	_bstr_t tmpSound("sound");
	_bstr_t tmpGravity("gravity");

	bool usingSprites = true;
	bool addRenderer = false;
	bool useGravity = true;
	MSXML::IXMLDOMNodePtr renderNode;

	float velocity;
	float duration;
	float horizontalDegree;
	float verticalDegree;
	float birthRate;
	float timetolive;
	int colGroup;
	int heathaze = 0;
	SoundNode* sound = NULL;

	Vector position;
	Vector rotation;
	Vector dimension;
	Vector rotationalDegree;

	
	std::vector<Object3d*> objectVector;
	std::vector<Sprite*> spriteVector;

	for (MSXML::IXMLDOMNodePtr pChild = emitterNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpRotation) {
				rotation = tracePosition(pChild);
			} else if(pChild->nodeName == tmpDimension) {
				dimension = tracePosition(pChild);
			} else if(pChild->nodeName == tmpVelocity) {
				velocity = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpDuration) {
				duration = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpTimeToLive) {
				timetolive = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpHDegree) {
				horizontalDegree = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVDegree) {
				verticalDegree = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRDegree) {
				rotationalDegree = tracePosition(pChild);
			} else if(pChild->nodeName == tmpBirthRate) {
				birthRate = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpSprite) {
				Sprite* sprite = traceSprite(pChild);
				sprite->generatePhysicMesh(Object3d::COL_CONVEX);
				usingSprites = true;
				spriteVector.push_back(sprite);
				//pe->addRefNode(*sprite);
			} else if(pChild->nodeName == tmpEnvObject) {
				Object3d* obj = this->traceEnvironmentObject(pChild);
				usingSprites = false;
				objectVector.push_back(obj);
				//pe->addRefNode(*obj);
			} else if(pChild->nodeName == tmpColGroup) {
				colGroup = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpRenderer) {
				//this->traceRenderer(pChild, *pg);//pChild->firstChild->text);
				renderNode = pChild;
				addRenderer = true;
			} else if(pChild->nodeName == tmpHeatHaze) {
				heathaze = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpSound) {
				sound = this->traceSound(pChild->firstChild);
			} else if(pChild->nodeName == tmpGravity) {
				useGravity = (atoi(pChild->firstChild->text)==1);
			}
		}
	}

	ParticleEmitter *pe = (ParticleEmitter*) this->scene->createNode(GameScene::NODE_PARTICLEEMITTER);
	ParticleGroup *pg;
	pg = (ParticleGroup*) this->scene->createNode(Scene::NODE_PARTICLEGROUP, usingSprites);
	SPTR<Node> spe = this->scene->getSmartPointer(pe);
	
	if(addRenderer) {
		this->traceRenderer(renderNode, *pg);
	}/* else if(!usingSprites) {	//Standardmaessig haben Object3ds eh einen renderer
		SPTR<Renderer> renderer(new SimpleMeshRenderer);
		this->scene->connectNodeAndRenderer(node, renderer);
	}*/

	if(sound) {
		pe->addEmittingSound(sound);
	}

	if(usingSprites) {
		for(UINT i=0;i<spriteVector.size();i++) {
			pe->addRefNode(*spriteVector.at(i));
		}
	} else {
		for(UINT i=0;i<objectVector.size();i++) {
			pe->addRefNode(*objectVector.at(i));
		}
	}
	rotation = rotation*D3DX_PI/180;
	horizontalDegree*=(D3DX_PI/180);
	verticalDegree*=(D3DX_PI/180);
	//rotationalDegree = rotationalDegree*D3DX_PI/180;
	pe->setUseHeatHaze(heathaze==1);
	pe->setPosition(position);
	pe->setRotation(rotation);
	pe->setDimensions(dimension.x, dimension.y, dimension.z);
	pe->setEMParticleVelocity(velocity);
	pe->setEMEmissionDuration(duration);
	pe->setEMHorizontalDegree(horizontalDegree);
	pe->setEMVerticalDegree(verticalDegree);
	pe->setEMRotationalDegree(rotationalDegree.x, rotationalDegree.y, rotationalDegree.z);
	pe->setEMBirthRate(birthRate);
	pe->setEMParticleLifeTime(timetolive);
	pe->setColDetGroup(colGroup);
	pg->useGravity(useGravity);
	pg->addParticleEmitter(spe);

	return pe;
}

Object3d* GameSceneLoader::traceEnvironmentObject(MSXML::IXMLDOMNodePtr envNode) {
	/*<envObject>
		<position>...</position>
		<rotation>...</rotation>
		<xfile>asdf.x</xfile
		<pactor>...</pactor>
		<arrivaltime>10</arrivaltime>
		<timevariation>5</timevariation>
		<renderer>...</renderer>
	</envObject>*/
	_bstr_t tmpPosition("position");
	_bstr_t tmpRotation("rotation");
	_bstr_t tmpArrivaltime("arrivaltime");
	_bstr_t tmpVariation("timevariation");
	_bstr_t tmpPhysic("pactor");
	_bstr_t tmpRenderer("renderer");
	_bstr_t tmpXFile("xfile");
	_bstr_t tmpSoftKill("softkill");

	Vector position;
	Vector rotation;
	float arrivalTime = 0;
	float arrivalVariation = 0;
	float softKill=0;
	MSXML::IXMLDOMNodePtr physicChild;
	bool hasPActor = false;
	MSXML::IXMLDOMNodePtr rendererChild;
	bool hasRenderer = false;
	std::string xfile = "";
	for (MSXML::IXMLDOMNodePtr pChild = envNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpRotation) {
				rotation = tracePosition(pChild);
			}else if(pChild->nodeName == tmpArrivaltime) {
				arrivalTime = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVariation) {
				arrivalVariation = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpPhysic) {
				physicChild = pChild;
				hasPActor = true;
			} else if(pChild->nodeName == tmpRenderer) {
				rendererChild = pChild;
				hasRenderer = true;
			} else if(pChild->nodeName == tmpXFile) {
				xfile = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpSoftKill) {
				softKill = (FLOAT)atof(pChild->firstChild->text);
			}
		}
	}
	rotation = rotation*D3DX_PI/180;

	Object3d* obj = (Object3d*) this->scene->createNode(GameScene::NODE_OBJECT3D, !hasRenderer);
	if(hasRenderer) {
		this->traceRenderer(rendererChild, *obj);
	}
	obj->setPosition(position);
	obj->setRotation(rotation);
	obj->loadMeshFromFile(xfile);
	if(softKill!=0) {
		obj->setSoftKill(true, softKill);
	}
	if(hasPActor) {
		this->tracePActor(physicChild, *obj);
	}
	if(arrivalTime!=0 /*&& arrivalVariation!=0*/) {
		obj->setStandBy(true);
		this->scene->setTrigger(GameScene::TRIGGER_UNSETSTANDBY, obj, this->scene->getRandomTime(arrivalTime, arrivalVariation));
	}
	return obj;
}

Sprite* GameSceneLoader::traceSprite(MSXML::IXMLDOMNodePtr spriteNode) {
	/*<particleFlaeche>
		<dimension>
			<x>-50</x>
			<y>50</y>
			<z>0</z>
		</dimension>
		<texture0>./media/textures/explosion1.bmp</texture0>
		<lookAtCamera>1</lookAtCamera> <!-- 0 = FALSE, 1 = TRUE -->
	</particleFlaeche>*/

	_bstr_t tmpDimension("dimension");
	_bstr_t tmpTexture0("texture0");
	_bstr_t tmpLookAtCamera("lookAtCamera");
	_bstr_t tmpAnimation("animation");
		_bstr_t tmpFps("fps");
		_bstr_t tmpFrameCount("framecount");
		_bstr_t tmpRowcount("rowcount");
		_bstr_t tmpColumncount("columncount");
		_bstr_t tmpLoopanimation("loopanimation");
	_bstr_t tmpKey1("key_start");
	_bstr_t tmpKey2("key_middle");
	_bstr_t tmpKey3("key_end");
		_bstr_t tmpAlpha("alpha");
		_bstr_t tmpRed("red");
		_bstr_t tmpGreen("green");
		_bstr_t tmpBlue("blue");
		_bstr_t tmpWidth("width");
		_bstr_t tmpHeight("height");
		_bstr_t tmpTime("time");

	std::string texture0;
	int lookAtCamera;
    Vector dimension;

	bool hasAnimation = false;
	int FPS = 1;
	int FrameCount = 1;
	int RowCount = 1;
	int ColumnCount = 1;
	bool loop = true;

	bool hasKey1 = false;
	bool hasKey2 = false;
	bool hasKey3 = false;

	float alpha[3] = {0.0f, 0.0f, 0.0f};
	float red[3] = {0.0f, 0.0f, 0.0f};
	float green[3] = {0.0f, 0.0f, 0.0f};
	float blue[3] = {0.0f, 0.0f, 0.0f};
	float width[3] = {0.0f, 0.0f, 0.0f};
	float height[3] = {0.0f, 0.0f, 0.0f};
	float time[3] = {0.0f, 0.0f, 1.0f};

	Sprite* sp = (Sprite*) this->scene->createNode(GameScene::NODE_SPRITE);

	for (MSXML::IXMLDOMNodePtr pChild = spriteNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpDimension) {
				dimension = tracePosition(pChild);
			} else if(pChild->nodeName == tmpTexture0) {
				texture0 = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpLookAtCamera) {
				lookAtCamera = atoi(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpAnimation) {
				hasAnimation = true;
				for (MSXML::IXMLDOMNodePtr pChildAnimation = pChild->firstChild;NULL != pChildAnimation;pChildAnimation = pChildAnimation->nextSibling) {
					if(pChildAnimation->nodeName == tmpFps) {
						FPS = atoi(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpFrameCount) {
						FrameCount = atoi(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpRowcount) {
						RowCount = atoi(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpColumncount) {
						ColumnCount = atoi(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpFrameCount) {
						FrameCount = atoi(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpLoopanimation) {
						if(atoi(pChildAnimation->firstChild->text) != 1) {
							loop = false;
						}
					}
				}
			} else if(pChild->nodeName == tmpKey1) {
				hasKey1 = true;
				for (MSXML::IXMLDOMNodePtr pChildAnimation = pChild->firstChild;NULL != pChildAnimation;pChildAnimation = pChildAnimation->nextSibling) {
					if(pChildAnimation->nodeName == tmpAlpha) {
						alpha[0] = (FLOAT)atof(pChild->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpRed) {
						red[0] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpGreen) {
						green[0] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpBlue) {
						blue[0] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpWidth) {
						width[0] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpHeight) {
						height[0] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} 
				}
			} else if(pChild->nodeName == tmpKey2) {
				hasKey2 = true;
				for (MSXML::IXMLDOMNodePtr pChildAnimation = pChild->firstChild;NULL != pChildAnimation;pChildAnimation = pChildAnimation->nextSibling) {
					if(pChildAnimation->nodeName == tmpAlpha) {
						alpha[1] = (FLOAT)atof(pChild->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpRed) {
						red[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpGreen) {
						green[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpBlue) {
						blue[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpWidth) {
						width[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpHeight) {
						height[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpTime) {
						time[1] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} 
				}
			} else if(pChild->nodeName == tmpKey3) {
				hasKey3 = true;
				for (MSXML::IXMLDOMNodePtr pChildAnimation = pChild->firstChild;NULL != pChildAnimation;pChildAnimation = pChildAnimation->nextSibling) {
					if(pChildAnimation->nodeName == tmpAlpha) {
						alpha[2] = (FLOAT)atof(pChild->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpRed) {
						red[2] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpGreen) {
						green[2] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpBlue) {
						blue[2] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpWidth) {
						width[2] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} else if(pChildAnimation->nodeName == tmpHeight) {
						height[2] = (FLOAT)atof(pChildAnimation->firstChild->text);
					} 
				}
			}
		}
	}

	sp->setDimension(dimension.x, dimension.y);
	sp->setTexture(texture0);
	sp->setLookAtCamera(lookAtCamera==1);
	
	if(hasAnimation) {
		sp->setFPS(FPS);
		sp->setFrameCount(FrameCount);
		sp->setRowColumnCount(RowCount, ColumnCount);
		sp->setLoopAnimation(true); // there's a bug if i set this to false
	}

	if(hasKey1 && hasKey2 && hasKey3) {
		sp->setKeyFrame(Sprite::KEY_START, alpha[0], red[0], green[0], blue[0], width[0], height[0], time[0]);
		sp->setKeyFrame(Sprite::KEY_MIDDLE, alpha[1], red[1], green[1], blue[1], width[1], height[1], time[1]);
		sp->setKeyFrame(Sprite::KEY_END, alpha[2], red[2], green[2], blue[2], width[2], height[2], time[2]);
	}

	return sp;
}

SoundNode* GameSceneLoader::traceSound(MSXML::IXMLDOMNodePtr soundNode)
{
	_bstr_t tmpPosition("position");
	_bstr_t tmpArrivaltime("arrivaltime");
	_bstr_t tmpVariation("timevariation");
	_bstr_t tmpSoundfile("soundfile");
	_bstr_t tmpSoundVolume("volume");
	_bstr_t tmpKillAfterPlayed("killafterplayed");
	_bstr_t tmpLoop("loop");
    
	Vector position;
	float arrivalTime = 0;
	float arrivalVariation = 0;
	std::string soundfile;
	float volume = 1;
	bool killAfterPlayed;
	bool loop;
	
	for (MSXML::IXMLDOMNodePtr pChild = soundNode->firstChild;NULL != pChild;pChild = pChild->nextSibling) {
		if(pChild->nodeType == MSXML::NODE_ELEMENT) {
			if(pChild->nodeName == tmpPosition) {
				position = tracePosition(pChild);
			} else if(pChild->nodeName == tmpArrivaltime) {
				arrivalTime = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpVariation) {
				arrivalVariation = (FLOAT)atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpSoundfile) {
				soundfile = pChild->firstChild->text;
			} else if(pChild->nodeName == tmpSoundVolume) {
				volume = (FLOAT) atof(pChild->firstChild->text);
			} else if(pChild->nodeName == tmpKillAfterPlayed) {
				killAfterPlayed = ((INT)atoi(pChild->firstChild->text)==1);
			} else if(pChild->nodeName == tmpLoop) {
				loop = ((INT)atoi(pChild->firstChild->text)==1);
			}
		}
	}

	SoundNode* sound;
	sound = (SoundNode*) this->scene->createNode(Scene::NODE_SOUND);
	sound->loadFile(soundfile, loop);
	sound->setVolume(volume);
	sound->setKillSoundNodeAfterPlayed(killAfterPlayed);
	
	if(arrivalTime!=0) {
		sound->setStandBy(true);
		this->scene->setTrigger(GameScene::TRIGGER_UNSETSTANDBY, sound, this->scene->getRandomTime(arrivalTime, arrivalVariation));
	} else {
		sound->play();
	}

	return sound;
}