void World::readWaterIndex() {
	//filepath for the object file
	stringw path = WATER_INDEX;
	//the only tag in this file is the object tag to define a new object
	const stringw object("water");
	//initialize an XML reader
	io::IXMLReader* reader = Client::device->getFileSystem()->createXMLReader(path);

	//start the reading loop
	while (reader->read()) {
		  switch (reader->getNodeType()) {
			  //we found a new element
              case irr::io::EXN_ELEMENT:
				  //new <object> tag
				  if (object.equals_ignore_case(reader->getNodeName())) {
					  u16 id = reader->getAttributeValueAsInt(L"id");
					  u16 x = reader->getAttributeValueAsInt(L"x");
					  u16 y = reader->getAttributeValueAsInt(L"y");
					  u16 w = reader->getAttributeValueAsInt(L"w");
					  u16 l = reader->getAttributeValueAsInt(L"l");
					  float h = reader->getAttributeValueAsFloat(L"height");
					  water_index.push_back(WaterData(id, x, y,  w, l, h));
					  cout << "Water loaded " << id << " " << x << " " << y << " " << w << " " << l << " " << h << endl;
				  }
				  break;
		  }
	}

	//drop the xml reader
	reader->drop();
}

// Execute Console Event
void ConsoleState::executeConsoleEvent(stringw val)
{
	val.make_lower();

	if(val=="statelog")
	{	_coreApp->addLogItem(val); _coreApp->toggleStateLog();	}
	else if(val=="debugmode")
	{	_coreApp->addLogItem(val); _coreApp->toggleDebugMode(); }
	else if(val=="exit")
	{	_coreApp->exitApplication();	}
	else if(val.subString(0,4) == "exec")
	{	
		_coreApp->addLogItem(val);

		irr::core::stringc stateRef = val.subString(5,val.size()-5);

		if(stateRef == "mainmenu")
		{
			_coreApp->addLogItem("@Main Menu State - Added to Stack");
			_coreApp->getStateManager()->add(new MainMenuState(_coreApp));
		}
	}
	else
	{	_coreApp->addLogItem("[ERROR] Unknown Command");	}

	_coreApp->getInputManager()->resetString();
}

// ----------------------------------------------------------------------------
void Editor::writeResAndExePathIntoConfig()
{
    stringc p;
    IFileSystem* file_system = m_device->getFileSystem();
    IXMLReader*  xml_reader = file_system->createXMLReader(m_config_loc + "/config.xml");
    if (xml_reader)
    {
        const stringw node_name(L"data_dir");
        while (xml_reader->read())
        {
            if (xml_reader->getNodeType() == EXN_ELEMENT
                && node_name.equals_ignore_case(xml_reader->getNodeName()))
            {
                p = xml_reader->getAttributeValueSafe(L"path");
            }
        }
        xml_reader->drop();
    }

    std::ofstream f;
    f.open((m_config_loc + "/config.xml").c_str());
    f << "<config>\n";
    f << "  <data_dir path=\"" << p.c_str() << "\" />\n";

    if (!m_exe_loc.empty())
        f << "  <exe path=\"" << m_exe_loc.c_str() << "\" />\n";

    f << "  <res x=\"" << m_screen_size.Width << "\" y=\"";
    f << m_screen_size.Height << "\" />\n";
    f << "</config>\n";
    f.close();

} // writeResAndExePathIntoConfig

bool CGWIC_Cell::LoadObjectStates()
{
	path filenm = GWIC_CELLSTORE_DIR;
	filenm += GetCellFileSuffix();
	filenm += ".xml";
	IXMLReader* xml = graphics->getFileSystem()->createXMLReader(filenm);
	if (!xml) {
		std::cerr << "LoadObjectStates(): can't create xml reader for " << filenm.c_str() << std::endl;
		return false;
	}
	const stringw tg_obj(L"object");
	const stringw tg_pos(L"position");
	const stringw tg_opt(L"options");
	stringw cur_tag;
	path cfile;
	CIrrStrParser pos,rot,scl;
	CGWIC_GameObject* optr = NULL;
	while (xml->read()) {
		switch (xml->getNodeType()) {
		case EXN_ELEMENT:
			if ((cur_tag.empty()) && (tg_obj.equals_ignore_case(xml->getNodeName()))) {
				cur_tag = tg_obj;
				cfile = xml->getAttributeValueSafe(L"file");
				optr = new CGWIC_GameObject(cfile,GetCoord(),graphics,physics);
				if (!optr)
					std::cerr << "Failed to create object from " << cfile.c_str() << std::endl;
				else
					objects.push_back(optr);
			} else if ((cur_tag == tg_obj) && (optr)) {
				if (tg_pos.equals_ignore_case(xml->getNodeName())) {
					pos = xml->getAttributeValueSafe(L"pos");
					rot = xml->getAttributeValueSafe(L"rot");
					scl = xml->getAttributeValueSafe(L"scale");
					optr->SetPos(pos.ToVector3f());
					optr->SetScale(scl.ToVector3f());
					optr->SetRot(rot.ToVector3f());
				} else if (tg_pos.equals_ignore_case(xml->getNodeName())) {
					optr->SetPhysical(xml->getAttributeValueAsInt(L"physical"));
					optr->SetEnabled(xml->getAttributeValueAsInt(L"enabled"));
				}
			}
			break;
		case EXN_ELEMENT_END:
			cur_tag = L"";
			optr = NULL;
			break;
		default: break;
		}
	}
	xml->drop();
	return false;
}

//Display a ingame question
bool GUIGame::showDialogQuestion(stringw text, std::string sound )
{

	IGUIStaticText* txt_dialog=(IGUIStaticText*)GUIManager::getInstance()->getGUIElement(GUIManager::TXT_ID_DIALOG);
	IGUIButton* guiBtDialogCancel=(IGUIButton*)GUIManager::getInstance()->getGUIElement(GUIManager::BT_ID_DIALOG_CANCEL);
	//Pause the player during the dialog opening
	DynamicObjectsManager::getInstance()->getPlayer()->setAnimation("idle");

	//stringw text2 = (stringw)text.c_str();
	txt_dialog->setText(text.c_str());
	if(!guiBtDialogCancel->isVisible())
		guiBtDialogCancel->setVisible(true);

	GUIManager::getInstance()->setWindowVisible(GUIManager::GCW_DIALOG,true);
	App::getInstance()->setAppState(App::APP_WAIT_DIALOG);

	//Play dialog sound (yes you can record voices!)
    dialogSound = NULL;

	if (sound.size()>0)
    //if((sound.c_str() != "") | (sound.c_str() != NULL))
    {
        stringc soundName = "../media/sound/";
        soundName += sound.c_str();
        dialogSound = SoundManager::getInstance()->playSound2D(soundName.c_str());
    }

	return true;
}

// -----------------------------------------------------------------------------
void IconButtonWidget::setLabel(const stringw& new_label)
{
    if (m_label == NULL) return;

    m_label->setText( new_label.c_str() );
    setLabelFont();
}

	/*
		Add another icon which the user can click and select as cursor later on.
	*/
	void addIcon(const stringw& name, const SCursorSprite &sprite, bool addCursor=true)
	{
		// Sprites are just icons - not yet cursors. They can be displayed by Irrlicht sprite functions and be used to create cursors.
		SpriteBox->addItem(name.c_str(), sprite.SpriteId);
		Sprites.push_back(sprite);

		// create the cursor together with the icon?
		if ( addCursor )
		{
			/* Here we create a hardware cursor from a sprite */
			Device->getCursorControl()->addIcon(sprite);

			// ... and add it to the cursors selection listbox to the other system cursors.
			CursorBox->addItem(name.c_str());
		}
	}

/**
 * Advanced constructor. Used for pickable items placed in container objects loaded from map files.
 */
CGameObject::CGameObject(stringw _root, s32 _id, IXMLReader* xml, IVideoDriver* driver)
{
	s32 position = _root.findLastChar(L"/",1);
	stringc _name = _root.subString(position+1,_root.size()-position);
	stringc _path = _root.subString(0,position+1);

	animations.clear();
	m_ListOfAbilities_Default.clear();
	m_ListOfSkills_Default.clear();
	m_ListOfTrajectoryPaths.clear();
	isAnimated = false;
	name = _name;
	path = _path;
	root = _name;
	id = _id;
	isContainer = false;
	isMonster = false;
	isAnchored = false;
	isNPC = false;
	isPickable = false;
	isArea = false;
	isTrigger = false;
	isInvisible = false;
	isIllusion = false;
	isStatic = false;
	isTerrain = false;
	isTile = false;
	isWall = false;
	hasTrajectoryPath = false;
	isTrajectoryNode = false;
	trajectoryParent = NULL;
	m_IconTexture = 0;
	description = L"No description specified";
	script = _name + ".script"; //default, but can be different
	icon = _name + ".png"; //default, but can be different
	m_Driver = driver;
	nameID = 0;
	trajectoryPathFile = "";

	if(xml)
	{
		LoadPropertiesFromXMLFile(xml);
		xml->drop();
	}
}

void OptionsScreenPlayers::onNewPlayerWithName(const stringw& newName)
{
    ListWidget* players = this->getWidget<ListWidget>("players");
    if (players != NULL)
    {
        core::stringc newNameC(newName.c_str());
        players->addItem( newNameC.c_str(), translations->fribidize(newName) );
    }
}

// -----------------------------------------------------------------------------
void IconButtonWidget::setLabel(stringw new_label)
{
    if (m_label == NULL) return;
    
    m_label->setText( new_label.c_str() );
    
    const bool word_wrap = (m_properties[PROP_WORD_WRAP] == "true");
    const int max_w = m_label->getAbsolutePosition().getWidth();
    
    if (!word_wrap &&
        (int)GUIEngine::getFont()->getDimension(new_label.c_str()).Width > max_w + 4) // arbitrarily allow for 4 pixels
    {
        m_label->setOverrideFont( GUIEngine::getSmallFont() );
    }
    else
    {
        m_label->setOverrideFont( NULL );
    }
}

void Game::updateProgressBar(int newValue, stringw msg) {
    progBar->setVisible(false);
    progBar = env->addImage(rect<int>(0, (cfg_settings.WindowSize.Height-68), (cfg_settings.WindowSize.Width*newValue)/100, (cfg_settings.WindowSize.Height-20)));
    progBar->setImage(driver->getTexture("textures/bars/progressbar_bar_720.png"));
        progBar->setUseAlphaChannel(true);
    progText->setText(msg.c_str());
    driver->beginScene(true, true, SColor(0, 0, 0, 0));
    env->drawAll();
    driver->endScene();

    }

// -----------------------------------------------------------------------------
void ChangePasswordDialog::submit()
{
    const stringw current_password = m_current_password_widget->getText().trim();
    const stringw new_password1 = m_new_password1_widget->getText().trim();
    const stringw new_password2 = m_new_password2_widget->getText().trim();
    if (current_password.size() < 8 || current_password.size() > 30)
    {
        sfx_manager->quickSound("anvil");
        m_info_widget->setErrorColor();
        m_info_widget->setText(_("Current password invalid."), false);
    }
    else if (new_password1.size() < 8 || new_password1.size() > 30)
    {
        sfx_manager->quickSound("anvil");
        m_info_widget->setErrorColor();
        m_info_widget->setText(_("Password has to be between 8 and 30 characters long!"), false);
    }
    else if (new_password1 != new_password2)
    {
        sfx_manager->quickSound("anvil");
        m_info_widget->setErrorColor();
        m_info_widget->setText(_("Passwords don't match!"), false);
    }
    else
    {
        m_options_widget->setDeactivated();
        m_info_widget->setDefaultColor();
        Online::CurrentUser::get()->requestPasswordChange(current_password, new_password1, new_password2);
    }
}

void ZoneSoundLoader::readZonesFromFile(){

	m_firstRun = true; // dont remove this :) in here for good execution flow

	// clear the zone_index vector
	m_zone_index.clear();

	// read from .dat file which contains zone boundaries
	stringw reader_path = SOUND_INDEX;
	io::IXMLReader* reader = Client::device->getFileSystem()->createXMLReader(reader_path);

	const stringw zone("zone");

	// read through the zones
	while (reader->read()){

		switch (reader->getNodeType()) {
			// if new zone is found..
		case irr::io::EXN_ELEMENT:
			//new <object> tag
			if (zone.equals_ignore_case(reader->getNodeName())) {
				u16 id = reader->getAttributeValueAsInt(L"id");
				u16 x = reader->getAttributeValueAsInt(L"x");
				u16 z = reader->getAttributeValueAsInt(L"z");
				u16 tox = reader->getAttributeValueAsInt(L"tox");
				u16 toz = reader->getAttributeValueAsInt(L"toz");
				//stringw name = reader->getAttributeValue(L"name");
				const wchar_t* songName = reader->getAttributeValue(L"songName");
				const wchar_t* name = reader->getAttributeValue(L"name");
				wstring sN(songName);
				//std::cout << "Song name:" << endl;
				//std::wcout << sN.c_str() << endl;
				// push the object to a vector
				m_zone_index.push_back(ZoneData(id, x, z, tox, toz, name, songName));
			}
			break;
		}

	}
}

/** Collects the data entered into the gui and submits a login request.
 *  The login request is processes asynchronously b the ReqeustManager.
 */
void LoginScreen::login()
{
    // Reset any potential error message shown.
    LabelWidget *info_widget = getWidget<LabelWidget>("info");
    info_widget->setDefaultColor();
    info_widget->setText("", false);

    const stringw username = getWidget<TextBoxWidget>("username")
                            ->getText().trim();
    const stringw password = getWidget<TextBoxWidget>("password")
                            ->getText().trim();

    if (username.size() < 4 || username.size() > 30 || 
        password.size() < 8 || password.size() > 30    )
    {
        sfx_manager->quickSound("anvil");
        info_widget->setErrorColor();
        info_widget->setText(_("Username and/or password too short or too long."),
                             false);
    }
    else
    {
        m_options_widget->setDeactivated();
        info_widget->setDefaultColor();
        bool remember = getWidget<CheckBoxWidget>("remember")->getState();
        Online::CurrentUser::get()->requestSignIn(username,password, 
                                                  remember           );
    }
}   // login

// ----------------------------------------------------------------------------
std::list<stringc> Editor::readRecentlyOpenedList()
{
    std::list<stringc> list;

    IFileSystem* file_system = m_device->getFileSystem();
    IXMLReader*  xml_reader = file_system->createXMLReader(m_config_loc + "/recent.xml");

    stringc s;
    if (xml_reader)
    {
        const stringw file(L"file");
        while (xml_reader->read())
        {
            if (xml_reader->getNodeType() == EXN_ELEMENT
                && file.equals_ignore_case(xml_reader->getNodeName()))
            {
                s  = xml_reader->getAttributeValueSafe(L"name");
                list.push_back(s);
            }
        }
        xml_reader->drop();
    }
    return list;
} // readRecentlyOpenedList

// ----------------------------------------------------------------------------
void Editor::readConfigFile(IFileSystem* file_system)
{
    IXMLReader* xml_reader = file_system->createXMLReader(path(PHYSFS_getBaseDir())
                                                                    + "config.xml");

    if (!xml_reader)
    {
        path dir = PHYSFS_getUserDir();
        m_config_loc = dir + "/.stk-te";
        xml_reader = file_system->createXMLReader(m_config_loc + "/config.xml");
        if (!xml_reader)
        {
            PHYSFS_setWriteDir(dir.c_str());
            PHYSFS_mkdir(".stk-te");
            return;
        }
    }
    else m_config_loc = PHYSFS_getBaseDir();

    const stringw node_name(L"data_dir");
    const stringw res(L"res");
    const stringw exe(L"exe");
    while (xml_reader->read())
    {
        if (xml_reader->getNodeType() == EXN_ELEMENT)
        {
            if (res.equals_ignore_case(xml_reader->getNodeName()))
            {
                m_screen_size = dimension2du(
                    atol(((stringc)xml_reader->getAttributeValueSafe(L"x")).c_str()),
                    atol(((stringc)xml_reader->getAttributeValueSafe(L"y")).c_str()));
            }
            else  if (node_name.equals_ignore_case(xml_reader->getNodeName()))
            {
                m_data_loc = xml_reader->getAttributeValueSafe(L"path");
                m_icons_loc = m_data_loc + "editor/icons/";
            }
            else if (exe.equals_ignore_case(xml_reader->getNodeName()))
            {
                m_exe_loc = xml_reader->getAttributeValueSafe(L"path");
            }
        }
    }
    xml_reader->drop();
} // readConfigFile

void StoryModeLobbyScreen::onNewPlayerWithName(const stringw& newName)
{
    bool slot_found = false;
    
    PtrVector<PlayerProfile>& players = UserConfigParams::m_all_players;
    for (int n=0; n<players.size(); n++)
    {
        if (players[n].getName() == newName)
        {
            unlock_manager->setCurrentSlot(players[n].getUniqueID());
            unlock_manager->updateActiveChallengeList();
            slot_found = true;
            break;
        }
    }
    
    if (!slot_found)
    {
        fprintf(stderr, "[StoryModeLobbyScreen] ERROR: cannot find player corresponding to slot '%s'\n",
                core::stringc(newName.c_str()).c_str());
    }
    
    StateManager::get()->resetAndGoToScreen(MainMenuScreen::getInstance());
}

	/*
	Load xml from disk, overwrite default settings
	The xml we are trying to load has the following structure
	settings nested in sections nested in the root node, like so
	<pre>
		<?xml version="1.0"?>
		<mygame>
			<video>
				<setting name="driver" value="Direct3D9" />
				<setting name="fullscreen" value="0" />
				<setting name="resolution" value="1024x768" />
			</video>
		</mygame>
	</pre>
	*/
	bool load()
	{
		//if not able to create device don't attempt to load
		if (!NullDevice)
			return false;

		irr::io::IXMLReader* xml = NullDevice->getFileSystem()->createXMLReader(SettingsFile);	//create xml reader
		if (!xml)
			return false;

		const stringw settingTag(L"setting"); //we'll be looking for this tag in the xml
		stringw currentSection; //keep track of our current section
		const stringw videoTag(L"video"); //constant for videotag

		//while there is more to read
		while (xml->read())
		{
			//check the node type
			switch (xml->getNodeType())
			{
				//we found a new element
				case irr::io::EXN_ELEMENT:
				{
					//we currently are in the empty or mygame section and find the video tag so we set our current section to video
					if (currentSection.empty() && videoTag.equals_ignore_case(xml->getNodeName()))
					{
						currentSection = videoTag;
					}
					//we are in the video section and we find a setting to parse
					else if (currentSection.equals_ignore_case(videoTag) && settingTag.equals_ignore_case(xml->getNodeName() ))
					{
						//read in the key
						stringw key = xml->getAttributeValueSafe(L"name");
						//if there actually is a key to set
						if (!key.empty())
						{
							//set the setting in the map to the value,
							//the [] operator overrides values if they already exist or inserts a new key value
							//pair into the settings map if it was not defined yet
							SettingMap[key] = xml->getAttributeValueSafe(L"value");
						}
					}

					//..
					// You can add your own sections and tags to read in here
					//..
				}
				break;

				//we found the end of an element
				case irr::io::EXN_ELEMENT_END:
					//we were at the end of the video section so we reset our tag
					currentSection=L"";
				break;
			}
		}

		// don't forget to delete the xml reader
		xml->drop();

		return true;
	}

void CRaycastTankExample::createTank(const stringw file, const stringw collFile, const vector3df &pos, const f32 mass)
{
    IAnimatedMeshSceneNode *Node = device->getSceneManager()->addAnimatedMeshSceneNode(
        device->getSceneManager()->getMesh(file.c_str()));
	Node->setPosition(pos);
	//Node->setRotation(vector3df(-40,90,0));
	Node->setMaterialFlag(video::EMF_LIGHTING, true);
	//Node->setScale(vector3df(2,2,4));



	IGImpactMeshShape *shape = new IGImpactMeshShape(Node, device->getSceneManager()->getMesh(collFile.c_str()), mass);


	tank = world->addRigidBody(shape);

    // When using a raycast vehicle, we don't want this rigid body to deactivate.
	tank->setActivationState(EAS_DISABLE_DEACTIVATION);

    // Set some damping on the rigid body because the raycast vehicles tend to bounce a lot without a lot of tweaking.
    // (cheap fix for the example only)
	tank->setDamping(0.4, 0.4);

    // We create our vehicle, passing our newly created rigid body as a parameter.
	vehicle = world->addRaycastVehicle(tank);


    // Set up our wheel construction info. These values can be changed for each wheel,
    // and the values that you want to keep will stay the same, that way
    // all parameters for each wheel can stay the same for what needs to remain equal,
    // such as directions and suspension rest length.
    SWheelInfoConstructionInfo wheel;
    wheel.chassisConnectionPointCS = vector3df(0.0,-0.88,4.0);
    wheel.wheelDirectionCS = vector3df(0.0,-0.1,0.0);
    wheel.wheelAxleCS = vector3df(-0.5,0.0,0.0);
    wheel.suspensionRestLength = 0.6;
    wheel.wheelRadius = 8.0;
    wheel.isFrontWheel = true;

    // The bones are in the center of the mesh on the X axis, so we just set the width ourselves.
    // Do the left row of wheels.
    for(u32 i=0; i < Node->getJointCount(); i++)
    {
        // The bones that we need in this mesh are all named "RoadWheels" with a numerical suffix.
        // So we do a quick check to make sure that no unwanted bones get through as wheels.
        if(Node->getJointNode(i)->getName()[0] == 'R')
        {
            wheel.chassisConnectionPointCS = vector3df(-4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
            vehicle->addWheel(wheel);
        }
    }

    wheel.wheelAxleCS = vector3df(0.5,0.0,0.0);

    // Do the right row of wheels.
    for(u32 i=0; i < Node->getJointCount(); i++)
    {
        if(Node->getJointNode(i)->getName()[0] == 'R')
        {
            wheel.chassisConnectionPointCS = vector3df(4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
            vehicle->addWheel(wheel);
        }
    }


	for (u32 i=0;i<vehicle->getNumWheels();i++)
    {
        SWheelInfo &info = vehicle->getWheelInfo(i);

        info.suspensionStiffness = 0.08f;
        info.wheelDampingRelaxation = 20.0f;
        info.wheelDampingCompression = 20.0f;
        info.frictionSlip = 1000;
        info.rollInfluence = 0.1f;


        // We call updateWheel, which takes SWheelInfo as the first parameter,
        // and the ID of the wheel to apply that info to. This must
        // be called after any changes in order for the changes to actually take effect.
        vehicle->updateWheelInfo(i);
    }
}

			// TODO: Make private?  (Game needs to reach it, currently, in addAgent().)
			void logWindowMessage( const stringw text )
			{	logWindow->addItem( text.c_str() ); }// logMessage()