Differential D1822 Diff 7723 binaries/data/mods/public/gui/session/input.js

Changeset View

Standalone View

binaries/data/mods/public/gui/session/input.js

Show First 20 Lines • Show All 1,124 Lines • ▼ Show 20 Lines	function handleInputAfterGui(ev)
return false;		return false;
}		}

function doAction(action, ev)		function doAction(action, ev)
{		{
if (!controlsPlayer(g_ViewedPlayer))		if (!controlsPlayer(g_ViewedPlayer))
return false;		return false;

// If shift is down, add the order to the unit's order queue instead		return handleUnitsActions(Engine.GetTerrainAtScreenPoint(ev.x, ev.y), action);
		StanUnsubmitted Done Inline Actions can be inlined :) Stan: can be inlined :)
		luikoAuthorUnsubmitted Done Inline Actions you mean like... ? < return handleUnitsActions(Engine.GetTerrainAtScreenPoint(ev.x, ev.y), action); --- > const target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y); > return handleUnitsActions(target, action); luiko: you mean like... ? ``` < return handleUnitsActions(Engine.GetTerrainAtScreenPoint(ev.x, ev.y)…
		StanUnsubmitted Done Inline Actions Yes :) Stan: Yes :)
// of running it immediately
var orderone = Engine.HotkeyIsPressed("session.orderone");
var queued = Engine.HotkeyIsPressed("session.queue");
var target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);

if (g_UnitActions[action.type] && g_UnitActions[action.type].execute)
{
let selection = g_Selection.toList();
if (orderone)
{
// pick the first unit that can do this order.
let unit = selection.find(entity =>
["preSelectedActionCheck", "hotkeyActionCheck", "actionCheck"].some(method =>
g_UnitActions[action.type][method] &&
g_UnitActions[action.type][method](action.target \|\| undefined, [entity])
));
if (unit)
{
selection = [unit];
g_Selection.removeList(selection);
}
}
return g_UnitActions[action.type].execute(target, action, selection, queued);
}		}

error("Invalid action.type " + action.type);
return false;
}

function positionUnitsFreehandSelectionMouseMove(ev)		function positionUnitsFreehandSelectionMouseMove(ev)
{		{
// Converting the input line into a List of points.		// Converting the input line into a List of points.
// For better performance the points must have a minimum distance to each other.		// For better performance the points must have a minimum distance to each other.
let target = Vector2D.from3D(Engine.GetTerrainAtScreenPoint(ev.x, ev.y));		let target = Vector2D.from3D(Engine.GetTerrainAtScreenPoint(ev.x, ev.y));
if (!g_FreehandSelection_InputLine.length \|\|		if (!g_FreehandSelection_InputLine.length \|\|
target.distanceToSquared(g_FreehandSelection_InputLine[g_FreehandSelection_InputLine.length - 1]) >=		target.distanceToSquared(g_FreehandSelection_InputLine[g_FreehandSelection_InputLine.length - 1]) >=
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
function handleMinimapEvent(target)		function handleMinimapEvent(target)
{		{
// Partly duplicated from handleInputAfterGui(), but with the input being		// Partly duplicated from handleInputAfterGui(), but with the input being
// world coordinates instead of screen coordinates.		// world coordinates instead of screen coordinates.

if (inputState != INPUT_NORMAL)		if (inputState != INPUT_NORMAL)
return false;		return false;

var fromMinimap = true;		var fromMinimap = true;
		SilierUnsubmitted Done Inline Actions this can go inline Silier: this can go inline
var action = determineAction(undefined, undefined, fromMinimap);		var action = determineAction(undefined, undefined, fromMinimap);
		SilierUnsubmitted Done Inline Actions use let here please Silier: use let here please
if (!action)		if (!action)
return false;		return false;

var selection = g_Selection.toList();		return handleUnitsActions(target, action);
		}

var queued = Engine.HotkeyIsPressed("session.queue");		function handleUnitsActions(target, action)
		bbUnsubmitted Done Inline Actions we only handle 1 action at at a time and we have `g_UnitActions` so I propose `handleUnitAction` bb: we only handle 1 action at at a time and we have `g_UnitActions` so I propose `handleUnitAction`
if (g_UnitActions[action.type] && g_UnitActions[action.type].execute)		{
return g_UnitActions[action.type].execute(target, action, selection, queued);		// If shift is down, add the order to the unit's order queue instead
		StanUnsubmitted Not Done Inline Actions I'm not sure that comment is still accurate since now the order one can be any key you want. Also I think it's ALT but I'm not sure one would have to check the wiki Hotkeys patch. Stan: I'm not sure that comment is still accurate since now the order one can be any key you want.
		SilierUnsubmitted Not Done Inline Actions it is shift to queue orderds :) Silier: it is shift to queue orderds :)
		// of running it immediately
		const orderone = Engine.HotkeyIsPressed("session.orderone");
		bbUnsubmitted Not Done Inline Actions I don't recall any convention on consts inside function. We seem to be using let everywhere however bb: I don't recall any convention on consts inside function. We seem to be using let everywhere…
		luikoAuthorUnsubmitted Not Done Inline Actions It should, I prefer to use 'const' to specify that this identifier won't be reassigned I think is a plus to keep things simple. luiko: It should, I prefer to use 'const' to specify that this identifier won't be reassigned I think…
		let queued = Engine.HotkeyIsPressed("session.queue");

		if (!(g_UnitActions[action.type] && g_UnitActions[action.type].execute))
		StanUnsubmitted Done Inline Actions (!(a && b) ) <==> (!a \|\| !b) Not sure which one is more readable. @elexis, shouldn't we check for g_UnitActions && g_UnitActions.length ? Stan: (!(a && b) ) <==> (!a \|\| !b) Not sure which one is more readable. @elexis, shouldn't we check…
		SilierUnsubmitted Done Inline Actions g_UnitActions is initialised non empty in unit_actions.js so thiese checks would be redundant I think ! a \|\| !b is easier to read Silier: g_UnitActions is initialised non empty in unit_actions.js so thiese checks would be redundant…
		{
error("Invalid action.type " + action.type);		error("Invalid action.type " + action.type);
return false;		return false;
}		}

		let selection = g_Selection.toList();
		if (orderone)
		{
		// Pick the first unit that can do this order.
		const unit = selection.find(entity =>
		["preSelectedActionCheck", "hotkeyActionCheck", "actionCheck"].some(method =>
		g_UnitActions[action.type][method] &&
		g_UnitActions[action.type][method](action.target \|\| undefined, [entity])
		));
		if (unit)
		{
		selection = [unit];
		g_Selection.removeList(selection);
		}
		}
		StanUnsubmitted Done Inline Actions Invert the condition and make this an early return. Stan: Invert the condition and make this an early return.
		return g_UnitActions[action.type].execute(target, action, selection, queued);
		}
		StanUnsubmitted Done Inline Actions Can the code be turned into a function so that comment can be nuked ? Stan: Can the code be turned into a function so that comment can be nuked ?
		luikoAuthorUnsubmitted Done Inline Actions I thought about that, but I want to show this simpler, I would like do that too. luiko: I thought about that, but I want to show this simpler, I would like do that too.

function getEntityLimitAndCount(playerState, entType)		function getEntityLimitAndCount(playerState, entType)
{		{
		StanUnsubmitted Done Inline Actions Comment start with caps :) Stan: Comment start with caps :)
let ret = {		let ret = {
"entLimit": undefined,		"entLimit": undefined,
"entCount": undefined,		"entCount": undefined,
"entLimitChangers": undefined,		"entLimitChangers": undefined,
"canBeAddedCount": undefined		"canBeAddedCount": undefined
};		};
if (!playerState.entityLimits)		if (!playerState.entityLimits)
return ret;		return ret;
▲ Show 20 Lines • Show All 372 Lines • Show Last 20 Lines