/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "player.h"
#include "map.h"
#include "connection.h"
#include "constants.h"
#include "utility.h"


Player::Player():
	touching_ground(false),
	in_water(false),
	in_water_stable(false),
	swimming_up(false),
	inventory_backup(NULL),
	craftresult_is_preview(true),
	hp(20),
	peer_id(PEER_ID_INEXISTENT),
	m_selected_item(0),
	m_pitch(0),
	m_yaw(0),
	m_speed(0,0,0),
	m_position(0,0,0)
{
	updateName("<not set>");
	resetInventory();
}

Player::~Player()
{
	delete inventory_backup;
}

void Player::wieldItem(u16 item)
{
	m_selected_item = item;
}

void Player::resetInventory()
{
	inventory.clear();
	inventory.addList("main", PLAYER_INVENTORY_SIZE);
	inventory.addList("craft", 9);
	inventory.addList("craftresult", 1);
}

// Y direction is ignored
void Player::accelerate(v3f target_speed, f32 max_increase)
{
	v3f d_wanted = target_speed - m_speed;
	d_wanted.Y = 0;
	f32 dl_wanted = d_wanted.getLength();
	f32 dl = dl_wanted;
	if(dl > max_increase)
		dl = max_increase;
	
	v3f d = d_wanted.normalize() * dl;

	m_speed.X += d.X;
	m_speed.Z += d.Z;
	//m_speed += d;

#if 0 // old code
	if(m_speed.X < target_speed.X - max_increase)
		m_speed.X += max_increase;
	else if(m_speed.X > target_speed.X + max_increase)
		m_speed.X -= max_increase;
	else if(m_speed.X < target_speed.X)
		m_speed.X = target_speed.X;
	else if(m_speed.X > target_speed.X)
		m_speed.X = target_speed.X;

	if(m_speed.Z < target_speed.Z - max_increase)
		m_speed.Z += max_increase;
	else if(m_speed.Z > target_speed.Z + max_increase)
		m_speed.Z -= max_increase;
	else if(m_speed.Z < target_speed.Z)
		m_speed.Z = target_speed.Z;
	else if(m_speed.Z > target_speed.Z)
		m_speed.Z = target_speed.Z;
#endif
}

void Player::serialize(std::ostream &os)
{
	// Utilize a Settings object for storing values
	Settings args;
	args.setS32("version", 1);
	args.set("name", m_name);
	//args.set("password", m_password);
	args.setFloat("pitch", m_pitch);
	args.setFloat("yaw", m_yaw);
	args.setV3F("position", m_position);
	args.setBool("craftresult_is_preview", craftresult_is_preview);
	args.setS32("hp", hp);

	args.writeLines(os);

	os<<"PlayerArgsEnd\n";
	
	// If actual inventory is backed up due to creative mode, save it
	// instead of the dummy creative mode inventory
	if(inventory_backup)
		inventory_backup->serialize(os);
	else
		inventory.serialize(os);
}

void Player::deSerialize(std::istream &is)
{
	Settings args;
	
	for(;;)
	{
		if(is.eof())
			throw SerializationError
					("Player::deSerialize(): PlayerArgsEnd not found");
		std::string line;
		std::getline(is, line);
		std::string trimmedline = trim(line);
		if(trimmedline == "PlayerArgsEnd")
			break;
		args.parseConfigLine(line);
	}

	//args.getS32("version");
	std::string name = args.get("name");
	updateName(name.c_str());
	/*std::string password = "";
	if(args.exists("password"))
		password = args.get("password");
	updatePassword(password.c_str());*/
	m_pitch = args.getFloat("pitch");
	m_yaw = args.getFloat("yaw");
	m_position = args.getV3F("position");
	try{
		craftresult_is_preview = args.getBool("craftresult_is_preview");
	}catch(SettingNotFoundException &e){
		craftresult_is_preview = true;
	}
	try{
		hp = args.getS32("hp");
	}catch(SettingNotFoundException &e){
		hp = 20;
	}
	/*try{
		std::string sprivs = args.get("privs");
		if(sprivs == "all")
		{
			privs = PRIV_ALL;
		}
		else
		{
			std::istringstream ss(sprivs);
			ss>>privs;
		}
	}catch(SettingNotFoundException &e){
		privs = PRIV_DEFAULT;
	}*/

	inventory.deSerialize(is);
}

/*
	RemotePlayer
*/

#ifndef SERVER

RemotePlayer::RemotePlayer(
		scene::ISceneNode* parent,
		IrrlichtDevice *device,
		s32 id):
	scene::ISceneNode(parent, (device==NULL)?NULL:device->getSceneManager(), id),
	m_text(NULL)
{
	m_box = core::aabbox3d<f32>(-BS/2,0,-BS/2,BS/2,BS*2,BS/2);

	if(parent != NULL && device != NULL)
	{
		// ISceneNode stores a member called SceneManager
		scene::ISceneManager* mgr = SceneManager;
		video::IVideoDriver* driver = mgr->getVideoDriver();
		gui::IGUIEnvironment* gui = device->getGUIEnvironment();

		// Add a text node for showing the name
		wchar_t wname[1] = {0};
		m_text = mgr->addTextSceneNode(gui->getBuiltInFont(),
				wname, video::SColor(255,255,255,255), this);
		m_text->setPosition(v3f(0, (f32)BS*2.1, 0));

		// Attach a simple mesh to the player for showing an image
		scene::SMesh *mesh = new scene::SMesh();
		{ // Front
		scene::IMeshBuffer *buf = new scene::SMeshBuffer();
		video::SColor c(255,255,255,255);
		video::S3DVertex vertices[4] =
		{
			video::S3DVertex(-BS/2,0,0, 0,0,0, c, 0,1),
			video::S3DVertex(BS/2,0,0, 0,0,0, c, 1,1),
			video::S3DVertex(BS/2,BS*2,0, 0,0,0, c, 1,0),
			video::S3DVertex(-BS/2,BS*2,0, 0,0,0, c, 0,0),
		};
		u16 indices[] = {0,1,2,2,3,0};
		buf->append(vertices, 4, indices, 6);
		// Set material
		buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
		//buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
		buf->getMaterial().setTexture(0, driver->getTexture(getTexturePath("player.png").c_str()));
		buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
		buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
		//buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
		buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
		// Add to mesh
		mesh->addMeshBuffer(buf);
		buf->drop();
		}
		{ // Back
		scene::IMeshBuffer *buf = new scene::SMeshBuffer();
		video::SColor c(255,255,255,255);
		video::S3DVertex vertices[4] =
		{
			video::S3DVertex(BS/2,0,0, 0,0,0, c, 1,1),
			video::S3DVertex(-BS/2,0,0, 0,0,0, c, 0,1),
			video::S3DVertex(-BS/2,BS*2,0, 0,0,0, c, 0,0),
			video::S3DVertex(BS/2,BS*2,0, 0,0,0, c, 1,0),
		};
		u16 indices[] = {0,1,2,2,3,0};
		buf->append(vertices, 4, indices, 6);
		// Set material
		buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
		//buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
		buf->getMaterial().setTexture(0, driver->getTexture(getTexturePath("player_back.png").c_str()));
		buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
		buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
		buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
		// Add to mesh
		mesh->addMeshBuffer(buf);
		buf->drop();
		}
		m_node = mgr->addMeshSceneNode(mesh, this);
		mesh->drop();
		m_node->setPosition(v3f(0,0,0));
	}
}

RemotePlayer::~RemotePlayer()
{
	if(SceneManager != NULL)
		ISceneNode::remove();
}

void RemotePlayer::updateName(const char *name)
{
	Player::updateName(name);
	if(m_text != NULL)
	{
		wchar_t wname[PLAYERNAME_SIZE];
		mbstowcs(wname, m_name, strlen(m_name)+1);
		m_text->setText(wname);
	}
}

void RemotePlayer::move(f32 dtime, Map &map, f32 pos_max_d)
{
	m_pos_animation_time_counter += dtime;
	m_pos_animation_counter += dtime;
	v3f movevector = m_position - m_oldpos;
	f32 moveratio;
	if(m_pos_animation_time < 0.001)
		moveratio = 1.0;
	else
		moveratio = m_pos_animation_counter / m_pos_animation_time;
	if(moveratio > 1.5)
		moveratio = 1.5;
	m_showpos = m_oldpos + movevector * moveratio;
	
	ISceneNode::setPosition(m_showpos);
}

#endif

#ifndef SERVER
/*
	LocalPlayer
*/

LocalPlayer::LocalPlayer():
	m_sneak_node(32767,32767,32767),
	m_sneak_node_exists(false)
{
	// Initialize hp to 0, so that no hearts will be shown if server
	// doesn't support health points
	hp = 0;
	
	// No tool wielded initially
	wield = NULL;
}

LocalPlayer::~LocalPlayer()
{
}

void LocalPlayer::wieldItem(u16 item)
{
	m_selected_item = item;
	
	if(wield) {
		InventoryItem* i = inventory.getList("main")->getItem(m_selected_item);
	
		if(i && strcmp(i->getName(), "ToolItem") == 0) {
			wield->getMaterial(0).setTexture(0, i->getImageRaw());
			wield->setVisible(true);
		}
		else
			wield->setVisible(false);
	}
}

void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
		core::list<CollisionInfo> *collision_info)
{
	v3f position = getPosition();
	v3f oldpos = position;
	v3s16 oldpos_i = floatToInt(oldpos, BS);

	v3f old_speed = m_speed;

	/*std::cout<<"oldpos_i=("<<oldpos_i.X<<","<<oldpos_i.Y<<","
			<<oldpos_i.Z<<")"<<std::endl;*/

	/*
		Calculate new position
	*/
	if(is_frozen) {
		// Still move very slowly so as not to feel all completely stuck
		position += m_speed * dtime * 0.001;
	}
	else {
		position += m_speed * dtime;
	}
	
	/*
		If the player enters an unloaded chunk this is set to true.
	*/
	is_frozen = false;

	// Skip collision detection if a special movement mode is used
	bool free_move = g_settings.getBool("free_move");
	if(free_move)
	{
		setPosition(position);
		return;
	}

	/*
		Collision detection
	*/
	
	// Player position in nodes
	v3s16 pos_i = floatToInt(position, BS);
	
	/*
		Check if player is in water (the oscillating value)
	*/
	try{
		// If in water, the threshold of coming out is at higher y
		if(in_water)
		{
			v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
			in_water = content_liquid(map.getNode(pp).getContent());
		}
		// If not in water, the threshold of going in is at lower y
		else
		{
			v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
			in_water = content_liquid(map.getNode(pp).getContent());
		}
	}
	catch(InvalidPositionException &e)
	{
		in_water = false;
	}

	/*
		Check if player is in water (the stable value)
	*/
	try{
		v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
		in_water_stable = content_liquid(map.getNode(pp).getContent());
	}
	catch(InvalidPositionException &e)
	{
		in_water_stable = false;
	}

	/*
	        Check if player is climbing
	*/

	try {
	        v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
		v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
		is_climbing = ((content_features(map.getNode(pp).getContent()).climbable ||
				content_features(map.getNode(pp2).getContent()).climbable) && !free_move);
	}
	catch(InvalidPositionException &e)
	{
	        is_climbing = false;
	}

	/*
		Collision uncertainty radius
		Make it a bit larger than the maximum distance of movement
	*/
	//f32 d = pos_max_d * 1.1;
	// A fairly large value in here makes moving smoother
	f32 d = 0.15*BS;

	// This should always apply, otherwise there are glitches
	assert(d > pos_max_d);

	float player_radius = BS*0.35;
	float player_height = BS*1.7;
	
	// Maximum distance over border for sneaking
	f32 sneak_max = BS*0.4;

	/*
		If sneaking, player has larger collision radius to keep from
		falling
	*/
	/*if(control.sneak)
		player_radius = sneak_max + d*1.1;*/
	
	/*
		If sneaking, keep in range from the last walked node and don't
		fall off from it
	*/
	if(control.sneak && m_sneak_node_exists)
	{
		f32 maxd = 0.5*BS + sneak_max;
		v3f lwn_f = intToFloat(m_sneak_node, BS);
		position.X = rangelim(position.X, lwn_f.X-maxd, lwn_f.X+maxd);
		position.Z = rangelim(position.Z, lwn_f.Z-maxd, lwn_f.Z+maxd);
		
		f32 min_y = lwn_f.Y + 0.5*BS;
		if(position.Y < min_y)
		{
			position.Y = min_y;

			//v3f old_speed = m_speed;

			if(m_speed.Y < 0)
				m_speed<span class="hl com">/*</span>
<span class="hl com">Minetest</span>
<span class="hl com">Copyright (C) 2013 celeron55, Perttu Ahola &lt;celeron55&#64;gmail.com&gt;</span>
<span class="hl com"></span>
<span class="hl com">This program is free software; you can redistribute it and/or modify</span>
<span class="hl com">it under the terms of the GNU Lesser General Public License as published by</span>
<span class="hl com">the Free Software Foundation; either version 2.1 of the License, or</span>
<span class="hl com">(at your option) any later version.</span>
<span class="hl com"></span>
<span class="hl com">This program is distributed in the hope that it will be useful,</span>
<span class="hl com">but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="hl com">MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="hl com">GNU Lesser General Public License for more details.</span>
<span class="hl com"></span>
<span class="hl com">You should have received a copy of the GNU Lesser General Public License along</span>
<span class="hl com">with this program; if not, write to the Free Software Foundation, Inc.,</span>
<span class="hl com">51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.</span>
<span class="hl com">*/</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;test.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#include &lt;sstream&gt;</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;log.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;serialization.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;nodedef.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;noise.h&quot;</span><span class="hl ppc"></span>

<span class="hl kwc">class</span> TestFilePath <span class="hl opt">:</span> <span class="hl kwc">public</span> TestBase <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	<span class="hl kwd">TestFilePath</span><span class="hl opt">() {</span> <span class="hl kwc">TestManager</span><span class="hl opt">::</span><span class="hl kwd">registerTestModule</span><span class="hl opt">(</span><span class="hl kwa">this</span><span class="hl opt">); }</span>
	<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwd">getName</span><span class="hl opt">() {</span> <span class="hl kwa">return</span> <span class="hl str">&quot;TestFilePath&quot;</span><span class="hl opt">; }</span>

	<span class="hl kwb">void</span> <span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">);</span>

	<span class="hl kwb">void</span> <span class="hl kwd">testIsDirDelimiter</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testPathStartsWith</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveLastPathComponent</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveLastPathComponentWithTrailingDelimiter</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveRelativePathComponent</span><span class="hl opt">();</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> TestFilePath g_test_instance<span class="hl opt">;</span>

<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testIsDirDelimiter<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testPathStartsWith<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveLastPathComponent<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveLastPathComponentWithTrailingDelimiter<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveRelativePathComponent<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl slc">////////////////////////////////////////////////////////////////////////////////</span>

<span class="hl slc">// adjusts a POSIX path to system-specific conventions</span>
<span class="hl slc">// -&gt; changes &apos;/&apos; to DIR_DELIM</span>
<span class="hl slc">// -&gt; absolute paths start with &quot;C:\\&quot; on windows</span>
<span class="hl kwc">std</span><span class="hl opt">::</span>string <span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>string path<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwa">for</span> <span class="hl opt">(</span><span class="hl kwb">size_t</span> i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> path<span class="hl opt">.</span><span class="hl kwd">size</span><span class="hl opt">(); ++</span>i<span class="hl opt">) {</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>path<span class="hl opt">[</span>i<span class="hl opt">] ==</span> <span class="hl str">&apos;/&apos;</span><span class="hl opt">) {</span>
			path<span class="hl opt">.</span><span class="hl kwd">replace</span><span class="hl opt">(</span>i<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> DIR_DELIM<span class="hl opt">);</span>
			i <span class="hl opt">+=</span> <span class="hl kwc">std</span><span class="hl opt">::</span><span class="hl kwd">string</span><span class="hl opt">(</span>DIR_DELIM<span class="hl opt">).</span><span class="hl kwd">size</span><span class="hl opt">() -</span> <span class="hl num">1</span><span class="hl opt">;</span> <span class="hl slc">// generally a no-op</span>
		<span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl ppc">#ifdef _WIN32</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>path<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> <span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">)</span>
		path <span class="hl opt">=</span> <span class="hl str">&quot;C:&quot;</span> <span class="hl opt">+</span> path<span class="hl opt">;</span>
	<span class="hl ppc">#endif</span>

	<span class="hl kwa">return</span> path<span class="hl opt">;</span>
<span class="hl opt">}</span>


<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">testIsDirDelimiter</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;/&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;A&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
<span class="hl ppc">#ifdef _WIN32</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
<span class="hl ppc">#else</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
<span class="hl opt">}</span>


<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">testPathStartsWith</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
	<span class="hl kwb">const int</span> numpaths <span class="hl opt">=</span> <span class="hl num">12</span><span class="hl opt">;</span>
	<span class="hl kwc">std</span><span class="hl opt">::</span>string paths<span class="hl opt">[</span>numpaths<span class="hl opt">] = {</span>
		<span class="hl str">&quot;&quot;</span><span class="hl opt">,</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/minetest&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/minetest/bin&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/.minetest&quot;</span><span class="hl opt">),</span>
		<span class="hl