// Client_RPG - top-down camera, click-to-move, and RPG windows for GameMode_RPG.
exec("./ui.cs");
// The server probes with RPG_Probe; reply with serverCmdRPG_Hello(2) to play.

$RPGClient::Version = 2;
$RPGClient::Active = 0;
$RPGClient::Yaw = 0;
$RPGClient::Dist = 14;
$RPGClient::TopDownPitch = 0.95;
$RPGClient::PanX = 0;
$RPGClient::PanY = 0;
$RPGClient::PanMax = 48;
$RPGClient::PanSpeed = 0.42;
$RPGClient::CamTickSched = 0;
$RPGClient::LastCamSync = 0;
$RPGClient::MvF = 0;
$RPGClient::MvB = 0;
$RPGClient::MvL = 0;
$RPGClient::MvR = 0;
$RPGClient::HelloPending = 0;
$RPGClient::HelloLast = "";
$RPGClient::TopDownWatchSched = 0;
$RPGClient::CamSched = 0;
$RPGClient::LastClickTime = 0;

function RPGClient_NormPos(%ctrl, %pos)
{
	if (!isObject(%ctrl))
	{
		return "0.5 0.5";
	}
	%ext = %ctrl.getExtent();
	%w = getWord(%ext, 0);
	%h = getWord(%ext, 1);
	if (%w < 1)
	{
		%w = 1;
	}
	if (%h < 1)
	{
		%h = 1;
	}
	%x = getWord(%pos, 0) / %w;
	%y = 1 - getWord(%pos, 1) / %h;
	if (%x < 0)
	{
		%x = 0;
	}
	if (%x > 1)
	{
		%x = 1;
	}
	if (%y < 0)
	{
		%y = 0;
	}
	if (%y > 1)
	{
		%y = 1;
	}
	return %x SPC %y;
}

function RPGClient_Aspect()
{
	if (!isObject(Canvas))
	{
		return 1.333;
	}
	%ext = Canvas.getExtent();
	%w = getWord(%ext, 0);
	%h = getWord(%ext, 1);
	return %h > 0 ? %w / %h : 1.333;
}

function RPGClient_SendClick(%button, %pos)
{
	if (!isObject(ServerConnection))
	{
		return;
	}
	%now = getSimTime();
	if (%now - $RPGClient::LastClickTime < 80)
	{
		return;
	}
	$RPGClient::LastClickTime = %now;
	%norm = RPGClient_NormPos(RPGClient_Mouse, %pos);
	commandToServer('RPG_Click', %button, getWord(%norm, 0), getWord(%norm, 1), RPGClient_Aspect());
	schedule(1, 0, RPGClient_ApplyCamera, 1);
}

function RPGClient_Mouse::onMouseDown(%this, %mod, %pos, %clicks)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	RPGClient_SendClick(0, %pos);
}

function RPGClient_Mouse::onRightMouseDown(%this, %mod, %pos, %clicks)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	RPGClient_SendClick(1, %pos);
}

function RPGClient_Mouse::onWake(%this)
{
	if (isObject(Canvas))
	{
		%ext = Canvas.getExtent();
		%this.resize(0, 0, getWord(%ext, 0), getWord(%ext, 1));
	}
}

function RPGClient_ClampPan()
{
	%max = $RPGClient::PanMax;
	if ($RPGClient::PanX > %max)
	{
		$RPGClient::PanX = %max;
	}
	if ($RPGClient::PanX < -%max)
	{
		$RPGClient::PanX = -%max;
	}
	if ($RPGClient::PanY > %max)
	{
		$RPGClient::PanY = %max;
	}
	if ($RPGClient::PanY < -%max)
	{
		$RPGClient::PanY = -%max;
	}
}

function RPGClient_ViewTransform(%body, %yaw, %dist, %panX, %panY)
{
	%p = %body.getPosition();
	%cx = getWord(%p, 0) + %panX;
	%cy = getWord(%p, 1) + %panY;
	%cz = getWord(%p, 2) + 1.5;
	%pitch = $RPGClient::TopDownPitch;
	%bx = -mCos(%yaw) * mCos(%pitch) * %dist;
	%by = -mSin(%yaw) * mCos(%pitch) * %dist;
	%bz = mSin(%pitch) * %dist;
	%ex = %cx + %bx;
	%ey = %cy + %by;
	%ez = %cz + %bz;
	%eye = %ex @ " " @ %ey @ " " @ %ez;
	%euler = %pitch @ " 0 " @ (%yaw + $pi);
	%rot = eulerRadToMatrix(%euler);
	return %eye @ " " @ %rot;
}

function RPGClient_EnsureCursor()
{
	if (!$RPGClient::Active || !isObject(Canvas))
	{
		return;
	}
	if (Canvas.isCursorOn())
	{
		return;
	}
	lockMouse(0);
	cursorOn();
}

function RPGClient_CameraTick()
{
	$RPGClient::CamTickSched = 0;
	if (!$RPGClient::Active)
	{
		return;
	}
	%speed = $RPGClient::PanSpeed;
	%yaw = $RPGClient::Yaw;
	%fwdX = -mCos(%yaw);
	%fwdY = -mSin(%yaw);
	%rightX = mSin(%yaw);
	%rightY = -mCos(%yaw);
	if ($RPGClient::MvF)
	{
		$RPGClient::PanX = $RPGClient::PanX + %fwdX * %speed * $RPGClient::MvF;
		$RPGClient::PanY = $RPGClient::PanY + %fwdY * %speed * $RPGClient::MvF;
	}
	if ($RPGClient::MvB)
	{
		$RPGClient::PanX = $RPGClient::PanX - %fwdX * %speed * $RPGClient::MvB;
		$RPGClient::PanY = $RPGClient::PanY - %fwdY * %speed * $RPGClient::MvB;
	}
	if ($RPGClient::MvL)
	{
		$RPGClient::PanX = $RPGClient::PanX - %rightX * %speed * $RPGClient::MvL;
		$RPGClient::PanY = $RPGClient::PanY - %rightY * %speed * $RPGClient::MvL;
	}
	if ($RPGClient::MvR)
	{
		$RPGClient::PanX = $RPGClient::PanX + %rightX * %speed * $RPGClient::MvR;
		$RPGClient::PanY = $RPGClient::PanY + %rightY * %speed * $RPGClient::MvR;
	}
	RPGClient_ClampPan();
	RPGClient_ApplyCamera(0);
	$RPGClient::CamTickSched = schedule(32, 0, RPGClient_CameraTick);
}

function RPGClient_StartCameraTick()
{
	cancel($RPGClient::CamTickSched);
	$RPGClient::CamTickSched = schedule(32, 0, RPGClient_CameraTick);
}

function RPGClient_KeyMvForward(%val)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	$RPGClient::MvF = %val * $RunMultiplier;
}

function RPGClient_KeyMvBackward(%val)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	$RPGClient::MvB = %val * $RunMultiplier;
}

function RPGClient_KeyMvLeft(%val)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	$RPGClient::MvL = %val * $RunMultiplier;
}

function RPGClient_KeyMvRight(%val)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	$RPGClient::MvR = %val * $RunMultiplier;
}

function RPGClient_SendClickFromCursor(%button)
{
	if (!$RPGClient::Active || !isObject(Canvas))
	{
		return;
	}
	RPGClient_SendClick(%button, Canvas.getCursorPos());
}

function RPGClient_EnableOverlay()
{
	if (!isObject(PlayGui) || isObject(RPGClient_Mouse))
	{
		return;
	}
	new GuiMouseEventCtrl(RPGClient_Mouse)
	{
		className = "RPGClient_Mouse";
		horizSizing = "width";
		vertSizing = "height";
		position = "0 0";
		extent = "640 480";
		profile = "GuiDefaultProfile";
		visible = "1";
		enabled = "1";
	};
	PlayGui.add(RPGClient_Mouse);
	PlayGui.bringToFront(RPGClient_Mouse);
	if (isObject(RPGClient_KeyMap))
	{
		RPGClient_KeyMap.delete();
	}
	new ActionMap(RPGClient_KeyMap);
	RPGClient_KeyMap.bind(keyboard, w, RPGClient_KeyMvForward);
	RPGClient_KeyMap.bind(keyboard, s, RPGClient_KeyMvBackward);
	RPGClient_KeyMap.bind(keyboard, a, RPGClient_KeyMvLeft);
	RPGClient_KeyMap.bind(keyboard, d, RPGClient_KeyMvRight);
	RPGClient_KeyMap.bind(keyboard0, w, RPGClient_KeyMvForward);
	RPGClient_KeyMap.bind(keyboard0, s, RPGClient_KeyMvBackward);
	RPGClient_KeyMap.bind(keyboard0, a, RPGClient_KeyMvLeft);
	RPGClient_KeyMap.bind(keyboard0, d, RPGClient_KeyMvRight);
	RPGClient_KeyMap.bind(keyboard, left, RPGClient_YawLeft);
	RPGClient_KeyMap.bind(keyboard, right, RPGClient_YawRight);
	RPGClient_KeyMap.bind(keyboard0, left, RPGClient_YawLeft);
	RPGClient_KeyMap.bind(keyboard0, right, RPGClient_YawRight);
	RPGClient_KeyMap.bind(keyboard, equals, RPGClient_ZoomIn);
	RPGClient_KeyMap.bind(keyboard, minus, RPGClient_ZoomOut);
	RPGClient_KeyMap.bind(keyboard0, equals, RPGClient_ZoomIn);
	RPGClient_KeyMap.bind(keyboard0, minus, RPGClient_ZoomOut);
	RPGClient_KeyMap.bind(keyboard, m, RPGClient_ToggleCursor);
	RPGClient_KeyMap.bind(keyboard0, m, RPGClient_ToggleCursor);
	RPGClient_KeyMap.push();
	$mvFreeLook = 0;
	$firstPerson = 0;
	if (isObject(Canvas) && !Canvas.isCursorOn())
	{
		Canvas.cursorOn();
	}
	if (isObject(PlayGui))
	{
		PlayGui.killToolHud();
	}
}

function RPGClient_ToggleCursor(%val)
{
	if (!$RPGClient::Active || !%val)
	{
		return;
	}
	ToggleCursor(%val);
}

function RPGClient_DisableOverlay()
{
	cancel($RPGClient::CamSched);
	$RPGClient::CamSched = 0;
	cancel($RPGClient::CamTickSched);
	$RPGClient::CamTickSched = 0;
	$RPGClient::MvF = 0;
	$RPGClient::MvB = 0;
	$RPGClient::MvL = 0;
	$RPGClient::MvR = 0;
	if (isObject(RPGClient_KeyMap))
	{
		RPGClient_KeyMap.pop();
	}
	if (isObject(RPGClient_Mouse))
	{
		RPGClient_Mouse.delete();
	}
	$RPGClient::Active = 0;
}

function RPGClient_ApplyCamera(%forceSync)
{
	%conn = RPGClient_GetConn();
	if (!isObject(%conn))
	{
		return;
	}
	%body = %conn.Player;
	if (!isObject(%body))
	{
		%body = %conn.player;
	}
	if (!isObject(%body))
	{
		return;
	}
	%cam = %conn.getControlObject();
	if (!isObject(%cam) || %cam.getClassName() !$= "Camera")
	{
		%cam = %conn.Camera;
		if (!isObject(%cam))
		{
			%cam = %conn.camera;
		}
	}
	if (!isObject(%cam))
	{
		return;
	}
	%conn.setControlObject(%cam);
	$mvFreeLook = 0;
	$firstPerson = 0;
	$mvForwardAction = 0;
	$mvBackwardAction = 0;
	$mvLeftAction = 0;
	$mvRightAction = 0;
	%cam.unmountImage(0);
	%xfm = RPGClient_ViewTransform(%body, $RPGClient::Yaw, $RPGClient::Dist, $RPGClient::PanX, $RPGClient::PanY);
	%cam.setTransform(%xfm);
	%cam.setMode("Corpse", %body);
	%cam.setOrbitMode(%body, %xfm, 0, 32, $RPGClient::Dist);
	%cam.mode = "Corpse";
	%cam.thirdPersonOnly = 1;
	%now = getSimTime();
	if (%forceSync || %now - $RPGClient::LastCamSync > 120)
	{
		$RPGClient::LastCamSync = %now;
		commandToServer('RPG_CamSync', $RPGClient::Yaw, $RPGClient::Dist, $RPGClient::PanX, $RPGClient::PanY);
	}
}

function RPGClient_ScheduleCamera()
{
	cancel($RPGClient::CamSched);
	$RPGClient::CamSched = schedule(50, 0, RPGClient_ApplyCamera, 0);
	schedule(200, 0, RPGClient_ApplyCamera, 0);
	schedule(500, 0, RPGClient_ApplyCamera, 0);
	schedule(1200, 0, RPGClient_ApplyCamera, 0);
	schedule(2500, 0, RPGClient_ApplyCamera, 0);
}

function RPGClient_YawLeft(%val)
{
	if (!$RPGClient::Active || %val == 0)
	{
		return;
	}
	$RPGClient::Yaw = $RPGClient::Yaw - 0.06;
	RPGClient_ApplyCamera(1);
}

function RPGClient_YawRight(%val)
{
	if (!$RPGClient::Active || %val == 0)
	{
		return;
	}
	$RPGClient::Yaw = $RPGClient::Yaw + 0.06;
	RPGClient_ApplyCamera(1);
}

function RPGClient_ZoomIn(%val)
{
	if (!$RPGClient::Active || %val == 0)
	{
		return;
	}
	$RPGClient::Dist = getMax(6, $RPGClient::Dist - 0.6);
	RPGClient_ApplyCamera(1);
}

function RPGClient_ZoomOut(%val)
{
	if (!$RPGClient::Active || %val == 0)
	{
		return;
	}
	$RPGClient::Dist = getMin(32, $RPGClient::Dist + 0.6);
	RPGClient_ApplyCamera(1);
}

function RPGClient_CanSendCmd()
{
	return isObject(ServerConnection) || isObject(localClientConnection);
}

function RPGClient_GetConn()
{
	if (isObject(ServerConnection))
	{
		return ServerConnection;
	}
	if (isObject(localClientConnection))
	{
		return localClientConnection;
	}
	return 0;
}

function RPGClient_SendHello()
{
	if ($RPGClient::Server)
	{
		return;
	}
	if (!RPGClient_CanSendCmd())
	{
		return;
	}
	%now = getSimTime();
	if ($RPGClient::HelloLast !$= "" && %now - $RPGClient::HelloLast < 900)
	{
		return;
	}
	$RPGClient::HelloLast = %now;
	commandToServer('RPG_Hello', $RPGClient::Version);
	commandToServer('RPGHello', $RPGClient::Version);
	commandToServer('Message', "/rpg clienthello " @ $RPGClient::Version);
}

function clientCmdRPG_Probe()
{
	RPGClient_SendHello();
}

function clientCmdRPG_Welcome(%serverProto, %accepted)
{
	if (%accepted && %serverProto == $RPGClient::Version)
	{
		$RPGClient::HelloPending = 0;
		schedule(2500, 0, RPGClient_TopDownWatch);
	}
	else if (!%accepted)
	{
		echo("Client_RPG: server rejected handshake (server proto " @ %serverProto @ ")");
		schedule(1500, 0, RPGClient_SendHello);
	}
}

function RPGClient_TopDownWatch()
{
	$RPGClient::TopDownWatchSched = 0;
	if ($RPGClient::Active || $RPGClient::Server || !RPGClient_CanSendCmd())
	{
		return;
	}
	$RPGClient::HelloLast = "";
	RPGClient_SendHello();
	$RPGClient::TopDownWatchSched = schedule(2500, 0, RPGClient_TopDownWatch);
}

function RPGClient_EnsurePlayGui()
{
	if (!isObject(PlayGui) || !isObject(Canvas))
	{
		return 0;
	}
	if (Canvas.getContent() != PlayGui.getId())
	{
		Canvas.setContent(PlayGui);
	}
	return 1;
}

function clientCmdRPG_TopDown(%on, %yaw, %dist)
{
	if (%on && !RPGClient_EnsurePlayGui())
	{
		schedule(200, 0, clientCmdRPG_TopDown, %on, %yaw, %dist);
		return;
	}
	if (%on)
	{
		cancel($RPGClient::TopDownWatchSched);
		$RPGClient::TopDownWatchSched = 0;
		$RPGClient::Server = 1;
		$RPGClient::Active = 1;
		$RPGClient::Yaw = %yaw;
		$RPGClient::Dist = %dist > 0 ? %dist : 14;
		$RPGClient::PanX = 0;
		$RPGClient::PanY = 0;
		RPGClient_EnableOverlay();
		RPGClient_BindKeys();
		RPGClient_StartCameraTick();
		RPGClient_ScheduleCamera();
		RPGClient_EnsureCursor();
	}
	else
	{
		RPGClient_DisableOverlay();
		RPGClient_UnbindKeys();
	}
}

function clientCmdRPG_Hud(%hp, %maxHp, %silver, %load, %cap, %skillId, %skillValue, %blocking, %tHp, %tMax)
{
	RPGClient_Hud_Update(%hp, %maxHp, %silver, %load, %cap, %skillId, %skillValue, %tHp, %tMax);
}

function clientCmdRPG_HudOff()
{
	RPGClient_Hud_Hide();
}

function clientCmdRPG_Notify(%text, %sec)
{
	if (%text !$= "")
	{
		RPGClient_Notify_Show(%text, %sec);
	}
}

function clientCmdRPG_Dialog(%title, %body, %sec)
{
	RPGClient_Dialog_Show(%title, %body, %sec);
}

function clientCmdRPG_ListBegin(%title, %page, %pages)
{
	RPGClient_List_Begin(%title, %page, %pages);
}

function clientCmdRPG_ListRow(%row)
{
	RPGClient_List_Row(%row);
}

function clientCmdRPG_ListEnd()
{
	RPGClient_List_End();
}

// --- HUD / list / dialog (Phase 4): thin windows on PlayGui ---
function RPGClient_Hud_Ensure()
{
	if (isObject(RPGClient_Hud))
	{
		return;
	}
	new GuiTextCtrl(RPGClient_Hud)
	{
		horizSizing = "width";
		vertSizing = "top";
		position = "8 8";
		extent = "600 24";
		profile = "ChatHudMessageProfile";
		text = "";
	};
	PlayGui.add(RPGClient_Hud);
}

function RPGClient_Hud_Update(%hp, %maxHp, %silver, %load, %cap, %skillId, %skillValue, %tHp, %tMax)
{
	if (!$RPGClient::Active)
	{
		return;
	}
	RPGClient_Hud_Ensure();
	%t = "";
	if (%tMax > 0)
	{
		%t = " | Target " @ %tHp @ "/" @ %tMax;
	}
	RPGClient_Hud.setText("HP " @ %hp @ "/" @ %maxHp @ %t @ " | " @ %silver @ " silver | load " @ %load @ "/" @ %cap @ " | " @ %skillId @ " " @ %skillValue);
}

function RPGClient_Hud_Hide()
{
	if (isObject(RPGClient_Hud))
	{
		RPGClient_Hud.setText("");
	}
}

function RPGClient_Notify_Show(%text, %sec)
{
	RPGClient_Hud_Ensure();
	RPGClient_Hud.setText(%text);
	if (%sec > 0)
	{
		schedule(%sec * 1000, RPGClient_Hud, setText, "");
	}
}

function RPGClient_Dialog_Show(%title, %body, %sec)
{
	messageBoxOK(%title, %body, "");
}

function RPGClient_List_Begin(%title, %page, %pages)
{
	$RPGClient::ListBody = "";
	$RPGClient::ListTitle = %title @ " (" @ (%page + 1) @ "/" @ %pages @ ")";
}

function RPGClient_List_Row(%row)
{
	$RPGClient::ListBody = $RPGClient::ListBody @ %row @ "\n";
}

function RPGClient_List_End()
{
	if ($RPGClient::ListBody !$= "")
	{
		messageBoxOK($RPGClient::ListTitle, $RPGClient::ListBody, "");
	}
}

package RPGClient_BlockMouseFire
{
	function mouseFire(%val)
	{
		if ($RPGClient::Active)
		{
			if (%val)
			{
				RPGClient_SendClickFromCursor(0);
			}
			return;
		}
		Parent::mouseFire(%val);
	}

	function altTrigger(%val)
	{
		if ($RPGClient::Active)
		{
			if (%val)
			{
				RPGClient_SendClickFromCursor(1);
			}
			return;
		}
		Parent::altTrigger(%val);
	}
};
activatePackage(RPGClient_BlockMouseFire);

package RPGClient_MoveMap
{
	function moveforward(%val)
	{
		if ($RPGClient::Active)
		{
			$RPGClient::MvF = %val * $RunMultiplier;
			$mvForwardAction = 0;
			return;
		}
		Parent::moveforward(%val);
	}

	function movebackward(%val)
	{
		if ($RPGClient::Active)
		{
			$RPGClient::MvB = %val * $RunMultiplier;
			$mvBackwardAction = 0;
			return;
		}
		Parent::movebackward(%val);
	}

	function moveleft(%val)
	{
		if ($RPGClient::Active)
		{
			$RPGClient::MvL = %val * $RunMultiplier;
			$mvLeftAction = 0;
			return;
		}
		Parent::moveleft(%val);
	}

	function moveright(%val)
	{
		if ($RPGClient::Active)
		{
			$RPGClient::MvR = %val * $RunMultiplier;
			$mvRightAction = 0;
			return;
		}
		Parent::moveright(%val);
	}

	function PageUpNewChatHud(%val)
	{
		if ($RPGClient::Active && %val)
		{
			RPGClient_ZoomIn(1);
			return;
		}
		Parent::PageUpNewChatHud(%val);
	}

	function PageDownNewChatHud(%val)
	{
		if ($RPGClient::Active && %val)
		{
			RPGClient_ZoomOut(1);
			return;
		}
		Parent::PageDownNewChatHud(%val);
	}
};
activatePackage(RPGClient_MoveMap);

package RPGClient_Cursor
{
	function escapeMenu::toggle(%this)
	{
		if (%this.isAwake())
		{
			Canvas.popDialog(%this);
			if ($RPGClient::Active)
			{
				schedule(0, 0, RPGClient_EnsureCursor);
			}
			return;
		}
		if (Canvas.getContent().getName() $= "LoadingGui")
		{
			disconnect();
			return;
		}
		Canvas.pushDialog(%this);
	}
};
activatePackage(RPGClient_Cursor);

package RPGClient_ViewLock
{
	function toggleFirstPerson(%val)
	{
		if ($RPGClient::Active)
		{
			return;
		}
		Parent::toggleFirstPerson(%val);
	}

	function toggleFreeLook(%val)
	{
		if ($RPGClient::Active)
		{
			return;
		}
		Parent::toggleFreeLook(%val);
	}

	function dropCameraAtPlayer(%val)
	{
		if ($RPGClient::Active)
		{
			return;
		}
		Parent::dropCameraAtPlayer(%val);
	}
};
activatePackage(RPGClient_ViewLock);

package RPGClient_Cleanup
{
	function disconnectedCleanup(%doReconnect)
	{
		RPGClient_DisableOverlay();
		RPGClient_UnbindKeys();
		$RPGClient::Server = 0;
		$RPGClient::HelloPending = 0;
		$RPGClient::HelloLast = "";
		cancel($RPGClient::TopDownWatchSched);
		$RPGClient::TopDownWatchSched = 0;
		Parent::disconnectedCleanup(%doReconnect);
	}
};
activatePackage(RPGClient_Cleanup);

package RPGClient_Mission
{
	function onMissionDownloadComplete()
	{
		Parent::onMissionDownloadComplete();
		schedule(250, 0, RPGClient_SendHello);
	}
};
activatePackage(RPGClient_Mission);

echo("Client_RPG loaded (protocol " @ $RPGClient::Version @ ")");