private void UpdateCursorsVisibility()
{
int playerIndex = m_gameState.LocalToPlayerIndex(LocalPlayerIndex);
m_selectionVisibility = m_selection.HasSelected(playerIndex, playerIndex);
IsCursorVisible = m_selectionVisibility && m_locationVisibility;
}
private void Update()
{
if (m_gameState.IsActionsMenuOpened(LocalPlayerIndex))
{
if (!m_cameraController.IsInputEnabled)
{
m_cameraController.IsInputEnabled = true;
}
return;
}
if (m_gameState.IsMenuOpened(LocalPlayerIndex))
{
if (!m_cameraController.IsInputEnabled)
{
m_cameraController.IsInputEnabled = true;
}
return;
}
if (m_gameState.IsContextActionInProgress(LocalPlayerIndex))
{
if (!m_cameraController.IsInputEnabled)
{
m_cameraController.IsInputEnabled = true;
}
return;
}
if (m_gameState.IsPaused || m_gameState.IsPauseStateChanging)
{
return;
}
if (m_gameState.IsReplay)
{
return;
}
int playerIndex = PlayerIndex;
m_selectInterval -= Time.deltaTime;
m_unselectInterval -= Time.deltaTime;
bool multiselect = m_inputManager.GetButton(InputAction.RB, LocalPlayerIndex);
if (m_inputManager.GetButtonDown(InputAction.LMB, LocalPlayerIndex))
{
RaycastHit hitInfo;
if (Physics.Raycast(m_cameraController.Ray, out hitInfo))
{
Voxel voxel = hitInfo.transform.GetComponentInParent <Voxel>();
if (voxel != null)
{
VoxelData data = voxel.VoxelData;
if (VoxelData.IsControllableUnit(data.Type) && data.Owner == playerIndex)
{
m_unitSelection.ClearSelection(playerIndex);
m_unitSelection.Select(playerIndex, playerIndex, new[] { data.UnitOrAssetIndex });
}
else
{
m_unitSelection.ClearSelection(playerIndex);
}
}
else
{
m_unitSelection.ClearSelection(playerIndex);
}
}
else
{
m_unitSelection.ClearSelection(playerIndex);
}
if (m_boxSelector != null)
{
m_boxSelector.Activate();
}
}
if (m_inputManager.GetButtonDown(InputAction.LB, LocalPlayerIndex))
{
bool select = true;
if (multiselect)
{
long[] units = m_gameState.GetUnits(playerIndex).ToArray();
long unitIndex = GetAt(units, m_cameraController.MapCursor);
if (m_unitSelection.IsSelected(playerIndex, playerIndex, unitIndex))
{
m_unitSelection.Unselect(playerIndex, playerIndex, new[] { unitIndex });
m_wasSelected.Remove(unitIndex);
select = false;
}
}
if (select)
{
Select(playerIndex, multiselect);
m_selectInterval = 0.3f;
m_unselectInterval = float.PositiveInfinity;
m_multiselectMode = true;
}
else
{
m_selectInterval = float.PositiveInfinity;
m_unselectInterval = 0.3f;
}
}
else if (m_inputManager.GetButton(InputAction.LB, LocalPlayerIndex))
{
if (m_selectInterval <= 0)
{
Select(playerIndex, multiselect);
m_selectInterval = 0.2f;
}
if (m_unselectInterval <= 0)
{
Unselect(playerIndex);
m_unselectInterval = 0.2f;
}
m_cameraController.IsInputEnabled = false;
}
else if (m_inputManager.GetButtonUp(InputAction.LB, LocalPlayerIndex, false, false))
{
m_cameraController.IsInputEnabled = true;
}
if (m_inputManager.GetButtonDown(InputAction.RB, LocalPlayerIndex))
{
m_multiselectMode = false;
}
else if (m_inputManager.GetButtonUp(InputAction.RB, LocalPlayerIndex))
{
if (!m_multiselectMode)
{
if (!m_targetSelection.HasSelected(playerIndex))
{
m_wasSelected.Clear();
m_unitSelection.ClearSelection(playerIndex);
}
}
}
}
private void Update()
{
if (m_gameState.IsActionsMenuOpened(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsMenuOpened(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsContextActionInProgress(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsPaused || m_gameState.IsPauseStateChanging)
{
return;
}
int playerIndex = PlayerIndex;
if (m_mapCursor != m_cameraController.MapCursor)
{
m_mapCursor = m_cameraController.MapCursor;
VoxelData newSelectedTarget = null;
VoxelData target = null;
int width = m_map.Map.GetMapSizeWith(GameConstants.MinVoxelActorWeight);
if (m_mapCursor.Row >= 0 && m_mapCursor.Col >= 0 && m_mapCursor.Row < width && m_mapCursor.Col < width)
{
MapCell cell = m_map.Map.Get(m_mapCursor.Row, m_mapCursor.Col, m_cameraController.Weight);
for (int i = 0; i < m_selectedUnitDescriptors.Length; ++i)
{
SelectionDescriptor descriptor = m_selectedUnitDescriptors[i];
bool lowestPossible = true;
cell.GetDefaultTargetFor(descriptor.Type, descriptor.Weight, playerIndex, lowestPossible, out target, playerIndex);
if (target != null)
{
break;
}
}
}
if (target != null && target.VoxelRef != null && target.UnitOrAssetIndex != -1)
{
//Player could not destroy own units (and should not be able to select them as target)
if (!VoxelData.IsControllableUnit(target.Type) || target.Owner != playerIndex)
{
newSelectedTarget = target;
}
}
if (m_previouslySelected != newSelectedTarget)
{
if (newSelectedTarget == null)
{
ClearSelection();
m_selectedTarget = null;
m_previouslySelected = null;
}
else
{
m_previouslySelected = newSelectedTarget;
TryEnableTargetAutoSelectionMode();
if (m_isTargetAutoSelectionMode)
{
m_selectedTarget = newSelectedTarget;
TargetSelectionSelect(playerIndex, target.Owner, m_selectedTarget.UnitOrAssetIndex);
}
}
}
}
else
{
if (m_selectedTarget != null)
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(m_selectedTarget.Owner, m_selectedTarget.UnitOrAssetIndex);
if (dc != null && dc.IsAlive)
{
Coordinate cursorCoord = new Coordinate(m_cameraController.MapCursor, GameConstants.MinVoxelActorWeight, 0).ToWeight(dc.ControlledData.Weight);
if (cursorCoord.MapPos != dc.Coordinate.MapPos)
{
Coordinate coord = dc.Coordinate.ToWeight(GameConstants.MinVoxelActorWeight);
m_cameraController.MapPivot = coord.MapPos;
m_cameraController.SetVirtualMousePosition(coord, true, false);
m_mapCursor = m_cameraController.MapCursor;
}
}
}
}
if (m_inputManager.GetButtonDown(InputAction.X, LocalPlayerIndex))
{
bool hasSelected = m_targetSelection.HasSelected(playerIndex);
Select(playerIndex);
if (!hasSelected)
{
m_isTargetAutoSelectionMode = true;
}
}
else if (m_inputManager.GetButtonUp(InputAction.RB, LocalPlayerIndex))
{
m_isTargetAutoSelectionMode = false;
ClearSelection();
}
}
