Ticket #515: TripleClick.patch

source/gui/scripting/ScriptFunctions.cpp

@@ -128 +128 @@
     return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, player);
 }
 
+std::vector<entity_id_t> PickSimilarFriendlyEntities(void* UNUSED(cbdata), std::string templateName, bool onScreenOnly)
+{
+    return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, g_Game->GetPlayerID(), onScreenOnly);
+}
+
 CFixedVector3D GetTerrainAtPoint(void* UNUSED(cbdata), int x, int y)
 {
     CVector3D pos = g_Game->GetView()->GetCamera()->GetWorldCoordinates(x, y, true);
@@ -374 +379 @@
     // Entity picking
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, &PickEntitiesAtPoint>("PickEntitiesAtPoint");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
     scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtPoint>("GetTerrainAtPoint");
 
     // Network / game setup functions

source/simulation2/helpers/Selection.cpp

@@ -23 +23 @@
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpRangeManager.h"
+#include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/components/ICmpVisual.h"
 
@@ -130 +131 @@
 
     return hitEnts;
 }
+
+std::vector<entity_id_t> EntitySelection::PickSimilarEntities(CSimulation2& simulation, const CCamera& camera, std::string templateName, int owner, bool onScreenOnly)
+{
+    CmpPtr<ICmpTemplateManager> cmpTemplateManager(simulation, SYSTEM_ENTITY);
+    std::wstring entVisualActor(L"");
+    std::vector<entity_id_t> hitEnts;
+
+    std::vector<entity_id_t> entities = cmpTemplateManager->GetEntitiesUsingTemplate(templateName);
+    for (std::vector<entity_id_t>::iterator it = entities.begin(); it != entities.end(); ++it)
+    {
+        entity_id_t ent = *it;
+        // Ignore entities not owned by 'owner'
+        CmpPtr<ICmpOwnership> cmpOwnership(simulation.GetSimContext(), ent);
+        if (cmpOwnership.null() || cmpOwnership->GetOwner() != owner)
+            continue;
+
+        // Find the current interpolated model position.
+        // (We just use the centre position and not the whole bounding box, because maybe
+        // that's better for users trying to select objects in busy areas)
+        CmpPtr<ICmpVisual> cmpVisual(simulation.GetSimContext(), ent);
+        if (cmpVisual.null())
+            continue;
+        CVector3D position = cmpVisual->GetPosition();
+
+        // Reject if it's not on-screen (e.g. it's behind the camera)
+        if (onScreenOnly && !camera.GetFrustum().IsPointVisible(position))
+            continue;
+
+        // Take all remaining units, whose template matches the input template
+        if (cmpTemplateManager->GetCurrentTemplateName(ent) == templateName)
+            hitEnts.push_back(ent);
+    }
+    return hitEnts;
+
+}

source/simulation2/helpers/Selection.h

@@ -47 +47 @@
  */
 std::vector<entity_id_t> PickEntitiesInRect(CSimulation2& simulation, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, int owner);
 
+/**
+ * Finds a selectable entity under the given screen coordinate
+ * and returns all units with the same visualActors short name,
+ * when onScreenOnly is set, only Units on screen are returned.
+ */
+std::vector<entity_id_t> PickSimilarEntities(CSimulation2& simulation, const CCamera& camera, std::string templateName, int owner, bool onScreenOnly);
+
 } // namespace
 
 #endif // INCLUDED_SELECTION

source/simulation2/components/ICmpTemplateManager.h

@@ -80 +80 @@
     virtual std::string GetCurrentTemplateName(entity_id_t ent) = 0;
 
     /**
+     * Returns the list of entities having the specified template
+     */
+    virtual std::vector<entity_id_t> GetEntitiesUsingTemplate(std::string templateName) = 0;
+    /**
      * Returns a list of strings that could be validly passed as @c templateName to LoadTemplate.
      * (This includes "actor|foo" etc names).
      * Intended for use by the map editor. This is likely to be quite slow.

source/simulation2/components/CCmpTemplateManager.cpp

@@ -131 +131 @@
 
     virtual std::vector<std::wstring> FindAllTemplates();
 
+    virtual std::vector<entity_id_t> GetEntitiesUsingTemplate(std::string templateName);
+
 private:
     // Entity template XML validator
     RelaxNGValidator m_Validator;
@@ -405 +407 @@
     return templates;
 }
 
+std::vector<entity_id_t> CCmpTemplateManager::GetEntitiesUsingTemplate(std::string templateName)
+{
+    std::vector<entity_id_t> entities;
+    for (std::map<entity_id_t, std::string>::const_iterator it = m_LatestTemplates.begin(); it != m_LatestTemplates.end(); ++it)
+    {
+        if(it->second.compare(templateName) == 0)
+            entities.push_back(it->first);
+    }
+    return entities;
+}
+
 void CCmpTemplateManager::CopyPreviewSubset(CParamNode& out, const CParamNode& in, bool corpse)
 {
     // We only want to include components which are necessary (for the visual previewing of an entity)

source/simulation2/components/ICmpTemplateManager.cpp

@@ -25 +25 @@
 DEFINE_INTERFACE_METHOD_1("GetTemplate", const CParamNode*, ICmpTemplateManager, GetTemplate, std::string)
 DEFINE_INTERFACE_METHOD_1("GetCurrentTemplateName", std::string, ICmpTemplateManager, GetCurrentTemplateName, entity_id_t)
 DEFINE_INTERFACE_METHOD_0("FindAllTemplates", std::vector<std::wstring>, ICmpTemplateManager, FindAllTemplates)
+DEFINE_INTERFACE_METHOD_1("GetEntitiesUsingTemplate", std::vector<entity_id_t>, ICmpTemplateManager, GetEntitiesUsingTemplate, std::string)
 END_INTERFACE_WRAPPER(TemplateManager)

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

@@ -38 +38 @@
 specialKeyStates[SDLK_RALT] = 0;
 specialKeyStates[SDLK_LALT] = 0;
 
+//Number of pixels the mouse can move before the action is considered a drag
+var maxDragDelta = 4;
+
+//Time in milliseconds in which a double click is recognized 
+const doubleClickTime = 500;  
+var doubleClickTimer = 0;
+var doubleClicked = false;
+//Store the previously clicked entity - ensure a double/triple click happens on the same entity
+var prevClickedEntity = 0;
 // (TODO: maybe we should fix the hotkey system to be usable in this situation,
 // rather than hardcoding Shift into this code?)
 
@@ -125 +134 @@
             var playerOwned = ((targetState.player == entState.player)? true : false);
             var enemyOwned = ((targetState.player != entState.player)? true : false);
             var gaiaOwned = ((targetState.player == 0)? true : false);
-
             
             if (targetState.garrisonHolder && playerOwned && ctrlPressed)
             {
@@ -571 +579 @@
             // If the mouse moved further than a limit, switch to bandbox mode
             var dragDeltaX = ev.x - dragStart[0];
             var dragDeltaY = ev.y - dragStart[1];
-            var maxDragDelta = 4;
+            
             if (Math.abs(dragDeltaX) >= maxDragDelta || Math.abs(dragDeltaY) >= maxDragDelta)
             {
                 inputState = INPUT_BANDBOXING;
@@ -586 +594 @@
             if (ev.button == SDL_BUTTON_LEFT)
             {
                 var ents = Engine.PickEntitiesAtPoint(ev.x, ev.y);
+                var selectedEntity;
+                var onScreenOnly;
+                
+                var now = new Date();
                 if (!ents.length)
                 {
                     g_Selection.reset();
                     inputState = INPUT_NORMAL;
                     return true;
                 }
+                else
+                {
+                    selectedEntity = ents[0];
+                }
+                if ((now.getTime() - doubleClickTimer < doubleClickTime) && (selectedEntity == prevClickedEntity))
+                {
+                    //Double click or triple click has occured
+                    
+                    //Check for double click or triple click
+                    if (!doubleClicked)
+                    {
+                        //If double click hasn't already occured
+                        //It's a double click
+                        //Select only similar on-screen units
+                        onScreenOnly = true;
+                        doubleClicked = true;
+                    }
+                    else
+                    {
+                        //Double click has already occured
+                        //This is a triple click
+                        //Select all similar units whether they are on-screen or not
+                        onScreenOnly = false;
+                    }
+                    
+                    var templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).template;
+                    
+                    ents = Engine.PickSimilarFriendlyEntities(templateToMatch, onScreenOnly);
+                }
+                else
+                {
+                    //It's single click right now but it may become double or triple click
+                    doubleClicked = false;
+                    doubleClickTimer = now.getTime();
+                    prevClickedEntity = selectedEntity;
+                }
 
                 // If shift is pressed, don't reset the selection, but allow units to be added to the existing selection
                 var addition = (specialKeyStates[SDLK_RSHIFT] || specialKeyStates[SDLK_LSHIFT]); 
                 if (!addition)
-                    g_Selection.reset(); 
-
-                g_Selection.addList([ents[0]]);
+                    g_Selection.reset();
+                if (doubleClicked)
+                {
+                    //Either double clicked or triple clicked
+                    //So we add all picked units to the selection
+                    g_Selection.addList(ents);
+                }
+                else
+                {
+                    //We add only the first picked unit to the selection
+                    g_Selection.addList([ents[0]]);
+                }
+                
                 inputState = INPUT_NORMAL;
                 return true;
             }