Ticket #1492: hotkeys_total.2.patch

binaries/data/config/default.cfg

@@ -119 +119 @@
 hotkey.screenshot = F2                      ; Take PNG screenshot
 hotkey.bigscreenshot = "Shift+F2"           ; Take large BMP screenshot
 hotkey.togglefullscreen = "Alt+Return"      ; Toggle fullscreen/windowed mode
-hotkey.screenshot.watermark = "K"           ; Toggle product/company watermark for official screenshots
+hotkey.screenshot.watermark = "R"           ; Toggle product/company watermark for official screenshots
 hotkey.wireframe = "Alt+W"                  ; Toggle wireframe mode
 hotkey.silhouettes = "Alt+S"                ; Toggle unit silhouettes
 
 ; > CAMERA SETTINGS
-hotkey.camera.reset = "H"                                 ; Reset camera rotation to default.
+hotkey.camera.reset = "X"                                 ; Reset camera rotation to default.
 hotkey.camera.follow = "F"                                ; Follow the first unit in the selection
 hotkey.camera.zoom.in = Plus, Equals, NumPlus             ; Zoom camera in (continuous control)
 hotkey.camera.zoom.out = Minus, NumMinus                  ; Zoom camera out (continuous control)
@@ -155 +155 @@
 hotkey.selection.milonly = Alt              ; Add only military units to selection
 hotkey.selection.remove = Ctrl              ; Remove units from selection
 hotkey.selection.idleworker = Period        ; Select next idle worker
+hotkey.selection.structure = Y              ; Select structure
+hotkey.selection.civilcenter = U            ; Select towncenter
+hotkey.selection.dropsiteres = I            ; Select dropsite stone/wood/metal
+hotkey.selection.dropsitefood = O           ; Select dropsite food
+hotkey.selection.market = P                 ; Select market
 hotkey.selection.idlewarrior = Comma        ; Select next idle warrior
 hotkey.selection.offscreen = Alt            ; Include offscreen units in selection
 hotkey.selection.group.select.0 = 0
@@ -188 +193 @@
 hotkey.selection.group.save.9 = "Ctrl+9"
 hotkey.selection.group.add.9 = "Shift+9"
 
+hotkey.selection.group.action.0 = G
+hotkey.selection.group.action.1 = H
+hotkey.selection.group.action.2 = J
+hotkey.selection.group.action.3 = K
+hotkey.selection.group.action.4 = L
+hotkey.selection.group.action.5 = Semicolon
+hotkey.selection.group.action.6 = SingleQuote
+hotkey.selection.group.action.7 = "Ctrl+G"
+hotkey.selection.group.action.8 = "Ctrl+H"
+hotkey.selection.group.action.9 = "Ctrl+J"
+hotkey.selection.group.action.10 = "Ctrl+K"
+hotkey.selection.group.action.11 = "Ctrl+L"
+hotkey.selection.group.action.12 = "Ctrl+Semicolon"
+hotkey.selection.group.action.13 = "Ctrl+SingleQuote"
+hotkey.selection.group.reset.0 = ForwardSlash
+hotkey.selection.group.stance.0 = V
+hotkey.selection.group.formation.0 = B
+hotkey.selection.group.garrison.0 = N
+hotkey.selection.group.ungarrison.0 = M
+
 ; > SESSION CONTROLS
 hotkey.session.kill = Delete                ; Destroy selected units
 hotkey.session.garrison = Ctrl              ; Modifier to garrison when clicking on building

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

@@ -14 +14 @@
 
 const ACTION_NONE = 0;
 const ACTION_GARRISON = 1;
-const ACTION_REPAIR = 2;
+const ACTION_BUILD = 2;
+const ACTION_TRAIN = 4;
+const ACTION_UNGARRISON = 8;
+const ACTION_FORMATION = 16;
+const ACTION_STANCE = 32;
+const ACTION_BARTER = 64;
+const ACTION_TRADER =128;
 var preSelectedAction = ACTION_NONE;
 
+var followQueue = [];
+
 const INPUT_NORMAL = 0;
 const INPUT_SELECTING = 1;
 const INPUT_BANDBOXING = 2;
@@ -27 +35 @@
 const INPUT_PRESELECTEDACTION = 7;
 const INPUT_BUILDING_WALL_CLICK = 8;
 const INPUT_BUILDING_WALL_PATHING = 9;
+const INPUT_ACTION_STATE = 10;
 
 var inputState = INPUT_NORMAL;
 var placementSupport = new PlacementSupport();
@@ -137 +146 @@
     return false;
 }
 
+function initBuildingPlacementView()
+{
+    if (placementSupport.mode === "wall")
+    {
+        // Including only the on-screen towers in the next snap candidate list is sufficient here, since the user is
+        // still selecting a starting point (which must necessarily be on-screen). (The update of the snap entities
+        // itself happens in the call to updateBuildingPlacementPreview below).
+        placementSupport.wallSnapEntitiesIncludeOffscreen = false;
+    }
+    else
+    {
+        var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
+            "template": placementSupport.template,
+            "x": placementSupport.position.x,
+            "z": placementSupport.position.z,
+        });
+        if (snapData)
+        {
+            placementSupport.angle = snapData.angle;
+            placementSupport.position.x = snapData.x;
+            placementSupport.position.z = snapData.z;
+        }
+    }
+    updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
+}
+
 function findGatherType(gatherer, supply)
 {
     if (!gatherer || !supply)
@@ -148 +183 @@
     return undefined;
 }
 
+function resetPreselectedAction()
+{
+    preSelectedAction = ACTION_NONE;
+    inputState = INPUT_NORMAL;
+    placementSupport.Reset(); // or a hotkey may leave a building snapshot
+    updateCursorAndTooltip();
+
+}
+
 function getActionInfo(action, target)
 {
     var selection = g_Selection.toList();
@@ -423 +467 @@
     {
         target = targets[0];
     }
+    if (Engine.HotkeyIsPressed("session.garrison"))
+        preSelectedAction = ACTION_GARRISON;
 
-    if (preSelectedAction != ACTION_NONE)
+    if (preSelectedAction & (ACTION_GARRISON|ACTION_BUILD))
     {
         switch (preSelectedAction)
         {
@@ -434 +480 @@
             else
                 return  {"type": "none", "cursor": "action-garrison-disabled", "target": undefined};
             break;
-        case ACTION_REPAIR:
+        case ACTION_BUILD:
             if (getActionInfo("repair", target).possible)
                 return {"type": "repair", "cursor": "action-repair", "target": target};
             else
@@ -442 +488 @@
             break;
         }
     }
-    else if (Engine.HotkeyIsPressed("session.garrison"))
-    {
-        if (getActionInfo("garrison", target).possible)
-            return {"type": "garrison", "cursor": "action-garrison", "target": target};
-        else
-            return  {"type": "none", "cursor": "action-garrison-disabled", "target": undefined};
-    }
     else
     {
         var actionInfo = undefined;
@@ -623 +662 @@
         mouseY = ev.y;
         break;
     }
-
+    if (followQueue.length)
+    {
+        var gents = followQueue;
+        var state = GetEntityState(gents[0]);
+        if (state.visibility == "hidden")
+            return true;
+        Engine.CameraFollow(0);
+        Engine.CameraFollow(gents[0]);
+        g_Selection.addList(gents);
+        resetPreselectedAction();
+        followQueue = []; // for next time.
+    }
     // Remember whether the mouse is over a GUI object or not
     mouseIsOverObject = (hoveredObject != null);
 
@@ -751 +801 @@
                     if (queued)
                         inputState = INPUT_BUILDING_PLACEMENT;
                     else
-                        inputState = INPUT_NORMAL;
+                        resetPreselectedAction();
                 }
                 else
                 {
@@ -765 +815 @@
             if (ev.button == SDL_BUTTON_RIGHT)
             {
                 // Cancel building
-                placementSupport.Reset();
-                inputState = INPUT_NORMAL;
+                resetPreselectedAction();
                 return true;
             }
             break;
@@ -975 +1024 @@
     switch (inputState)
     {
     case INPUT_NORMAL:
+    case INPUT_ACTION_STATE:
         switch (ev.type)
         {
         case "mousemotion":
@@ -1004 +1054 @@
             break;
 
         case "hotkeydown":
-                if (ev.hotkey.indexOf("selection.group.") == 0)
-                {
-                    var now = new Date();
-                    if ((now.getTime() - doublePressTimer < doublePressTime) && (ev.hotkey == prevHotkey))
-                    {
-                        if (ev.hotkey.indexOf("selection.group.select.") == 0)
-                        {
-                            var sptr = ev.hotkey.split(".");
-                            performGroup("snap", sptr[3]);
-                        }
-                    }
-                    else
-                    {
-                        var sptr = ev.hotkey.split(".");
-                        performGroup(sptr[2], sptr[3]);
-
-                        doublePressTimer = now.getTime();
-                        prevHotkey = ev.hotkey;
-                    }
-                }
-                break;
+            handleHotkey(ev);
+            break;
         }
         break;
         
@@ -1035 +1066 @@
             if (ev.button == SDL_BUTTON_LEFT && preSelectedAction != ACTION_NONE)
             {
                 var action = determineAction(ev.x, ev.y);
+                resetPreselectedAction();
                 if (!action)
                     break;
-                preSelectedAction = ACTION_NONE;
-                inputState = INPUT_NORMAL;
                 return doAction(action, ev);
             }
-            else if (ev.button == SDL_BUTTON_RIGHT && preSelectedAction != ACTION_NONE)
+            else if (ev.button == SDL_BUTTON_RIGHT)
             {
-                preSelectedAction = ACTION_NONE;
-                inputState = INPUT_NORMAL;
+                resetPreselectedAction();
                 break;
             }
-            // else
+        case "hotkeydown":
+            handleHotkey(ev);
+            break;
         default:
             // Slight hack: If selection is empty, reset the input state
             if (g_Selection.toList().length == 0)
             {
-                preSelectedAction = ACTION_NONE;
-                inputState = INPUT_NORMAL;
+                resetPreselectedAction();
                 break;
             }
         }
@@ -1084 +1114 @@
                 if (!ents.length)
                 {
                     g_Selection.reset();
-                    resetIdleUnit();
-                    inputState = INPUT_NORMAL;
+                    resetEntitySearch();
+                    resetPreselectedAction();
                     return true;
                 }
-
                 var selectedEntity = ents[0];
-                var now = new Date();
 
                 // If camera following and we select different unit, stop
                 if (Engine.GetFollowedEntity() != selectedEntity)
                 {
                     Engine.CameraFollow(0);
                 }
-
-                if ((now.getTime() - doubleClickTimer < doubleClickTime) && (selectedEntity == prevClickedEntity))
-                {
-                    // Double click or triple click has occurred
-                    var showOffscreen = Engine.HotkeyIsPressed("selection.offscreen");
-                    var matchRank = true;
-                    var templateToMatch;
-
-                    // Check for double click or triple click
-                    if (!doubleClicked)
-                    {
-                        // If double click hasn't already occurred, this is a double click.
-                        // Select similar units regardless of rank
-                        templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).identity.selectionGroupName;
-                        if (templateToMatch)
-                        {
-                            matchRank = false;
-                        }
-                        else
-                        {   // No selection group name defined, so fall back to exact match
-                            templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).template;
-                        }
-
-                        doubleClicked = true;
-                        // Reset the timer so the user has an extra period 'doubleClickTimer' to do a triple-click
-                        doubleClickTimer = now.getTime();
-                    }
-                    else
-                    {
-                        // Double click has already occurred, so this is a triple click.
-                        // Select units matching exact template name (same rank)
-                        templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).template;
-                    }
-
-                    // TODO: Should we handle "control all units" here as well?
-                    ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank, false);
-                }
-                else
-                {
-                    // It's single click right now but it may become double or triple click
-                    doubleClicked = false;
-                    doubleClickTimer = now.getTime();
-                    prevClickedEntity = selectedEntity;
-
-                    // We only want to include the first picked unit in the selection
-                    ents = [ents[0]];
-                }
-
-                // Update the list of selected units
-                if (Engine.HotkeyIsPressed("selection.add"))
-                {
-                    g_Selection.addList(ents);
-                }
-                else if (Engine.HotkeyIsPressed("selection.remove"))
-                {
-                    g_Selection.removeList(ents);
-                }
-                else
-                {
-                    g_Selection.reset();
-                    g_Selection.addList(ents);
-                }
-
-                inputState = INPUT_NORMAL;
+                ClickSelected(ents, (selectedEntity == prevClickedEntity));
                 return true;
             }
             break;
@@ -1171 +1136 @@
         switch (ev.type)
         {
         case "mousemotion":
-            
             placementSupport.position = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
-            
-            if (placementSupport.mode === "wall")
-            {
-                // Including only the on-screen towers in the next snap candidate list is sufficient here, since the user is
-                // still selecting a starting point (which must necessarily be on-screen). (The update of the snap entities
-                // itself happens in the call to updateBuildingPlacementPreview below).
-                placementSupport.wallSnapEntitiesIncludeOffscreen = false;
-            }
-            else
-            {
-                var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
-                    "template": placementSupport.template,
-                    "x": placementSupport.position.x,
-                    "z": placementSupport.position.z,
-                });
-                if (snapData)
-                {
-                    placementSupport.angle = snapData.angle;
-                    placementSupport.position.x = snapData.x;
-                    placementSupport.position.z = snapData.z;
-                }
-            }
-
-            updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
+            initBuildingPlacementView();
             return false; // continue processing mouse motion
 
         case "mousebuttondown":
@@ -1213 +1154 @@
                 else
                 {
                     placementSupport.position = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
-                    dragStart = [ ev.x, ev.y ];
-                    inputState = INPUT_BUILDING_CLICK;
+                    dragStart = [ ev.x, ev.y ];
+                    inputState = INPUT_BUILDING_CLICK;
                 }
                 return true;
             }
@@ -1222 +1163 @@
             {
                 // Cancel building
                 placementSupport.Reset();
-                inputState = INPUT_NORMAL;
+                resetPreselectedAction();
                 return true;
             }
             break;
@@ -1241 +1182 @@
                 placementSupport.angle -= rotation_step;
                 updateBuildingPlacementPreview();
                 break;
+            default:
+                handleHotkey(ev); // to switch buildings
             }
             break;
 
@@ -1250 +1193 @@
     return false;
 }
 
+function ClickSelected(ents, is_same)
+{
+    var selectedEntity = ents[0];
+    var now = new Date();
+
+    if ((now.getTime() - doubleClickTimer < doubleClickTime) && is_same)
+    {
+        // Double click or triple click has occurred
+        var showOffscreen = Engine.HotkeyIsPressed("selection.offscreen");
+        var matchRank = true;
+        var templateToMatch;
+
+        // Check for double click or triple click
+        if (!doubleClicked)
+        {
+            // If double click hasn't already occurred, this is a double click.
+            // Select similar units regardless of rank
+            templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).identity.selectionGroupName;
+            if (templateToMatch)
+            {
+                matchRank = false;
+            }
+            else
+            {   // No selection group name defined, so fall back to exact match
+                templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).template;
+            }
+
+            doubleClicked = true;
+            // Reset the timer so the user has an extra period 'doubleClickTimer' to do a triple-click
+            doubleClickTimer = now.getTime();
+        }
+        else
+        {
+            // Double click has already occurred, so this is a triple click.
+            // Select units matching exact template name (same rank)
+            templateToMatch = Engine.GuiInterfaceCall("GetEntityState", selectedEntity).template;
+        }
+
+        // TODO: Should we handle "control all units" here as well?
+        ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank, false);
+    }
+    else
+    {
+        // It's single click right now but it may become double or triple click
+        doubleClicked = false;
+        doubleClickTimer = now.getTime();
+        prevClickedEntity = selectedEntity;
+
+        // We only want to include the first picked unit in the selection
+        ents = [ents[0]];
+    }
+
+    // Update the list of selected units
+    if (Engine.HotkeyIsPressed("selection.add"))
+    {
+        g_Selection.addList(ents);
+    }
+    else if (Engine.HotkeyIsPressed("selection.remove"))
+    {
+        g_Selection.removeList(ents);
+    }
+    else
+    {
+        g_Selection.reset();
+        g_Selection.addList(ents);
+    }
+    resetPreselectedAction();
+}
+
 function doAction(action, ev)
 {
     var selection = g_Selection.toList();
@@ -1533 +1545 @@
                 break;
             case "repair":
                 inputState = INPUT_PRESELECTEDACTION;
-                preSelectedAction = ACTION_REPAIR;
+                preSelectedAction = ACTION_BUILD;
                 break;
             case "unload-all":
                 unloadAll(entity);
@@ -1577 +1589 @@
     }
 }
 
+function handleHotkey(ev)
+{
+    if (ev.hotkey && ev.hotkey.indexOf("selection.group.") == 0)
+    {
+        var sptr = ev.hotkey.split(".");
+        var now = new Date();
+        if ((inputState == INPUT_NORMAL) && (ev.hotkey == prevHotkey) &&
+                ev.hotkey.indexOf("selection.group.select.") == 0 &&
+                (now.getTime() - doublePressTimer < doublePressTime)) {
+            performGroup("snap", sptr[3]);
+        }
+        else
+        {
+            performGroup(sptr[2], sptr[3]);
+            doublePressTimer = now.getTime();
+            prevHotkey = ev.hotkey;
+        }
+    }
+}
+
 // Performs the specified group
-function performGroup(action, groupId)
+function performGroup(action, x)
 {
     switch (action)
     {
@@ -1587 +1619 @@
     case "add":
         var toSelect = [];
         g_Groups.update();
-        for (var ent in g_Groups.groups[groupId].ents)
+        for (var ent in g_Groups.groups[x].ents)
             toSelect.push(+ent);
 
         if (action != "add")
@@ -1597 +1629 @@
 
         if (action == "snap" && toSelect.length)
             Engine.CameraFollow(toSelect[0]);
-        break;
+        return;
     case "save":
         var selection = g_Selection.toList();
-        g_Groups.groups[groupId].reset();
-        g_Groups.addEntities(groupId, selection);
+        g_Groups.groups[x].reset();
+        g_Groups.addEntities(x, selection);
         updateGroups();
+        return;
+    case "action":
+        var selection = g_Selection.toList();
+        var player = Engine.GetPlayerID();
+        if (inputState != INPUT_ACTION_STATE)
+            preSelectedAction = getDefaultActionForSelection(player, selection);
         break;
+    case "reset":
+        resetPreselectedAction();
+        return;
+    case "garrison":
+        preSelectedAction = ACTION_GARRISON;
+        inputState = INPUT_PRESELECTEDACTION;
+        return;
+    case "ungarrison":
+        preSelectedAction = ACTION_UNGARRISON;
+        inputState = INPUT_ACTION_STATE;
+        return;
+    case "stance":
+        preSelectedAction = ACTION_STANCE;
+        inputState = INPUT_ACTION_STATE;
+        return;
+    case "formation":
+        preSelectedAction = ACTION_FORMATION;
+        inputState = INPUT_ACTION_STATE;
+        return;
+    }
+    if (inputState == INPUT_ACTION_STATE)
+        inputState = INPUT_NORMAL;
+    if (preSelectedAction == ACTION_NONE)
+        return;
+
+    var lst = selectAction(player, selection);
+    if (!lst) // shouldn't happen
+        return;
+
+    if (preSelectedAction & ACTION_GARRISON)
+    {
+        if (++x > lst.length)
+            x = lst.length;
+    } else if (preSelectedAction != ACTION_UNGARRISON) {
+        if (x >= lst.length)
+            return;
+        lst = lst[x];
     }
+
+    switch (preSelectedAction)
+    {
+    case ACTION_BUILD:
+        var tmpl = GetTemplateData(lst);
+        if (!tmpl.requiredTechnology || Engine.GuiInterfaceCall("IsTechnologyResearched", tmpl.requiredTechnology)) {
+            // N.B. sets inputState = INPUT_BUILDING_PLACEMENT:
+            startBuildingPlacement(lst);
+            placementSupport.position = Engine.GetTerrainAtScreenPoint(mouseX, mouseY);
+            initBuildingPlacementView();
+        }
+        break;
+    case ACTION_TRAIN:
+        var tmpl = GetTemplateData(lst);
+        if (!tmpl.requiredTechnology || Engine.GuiInterfaceCall("IsTechnologyResearched", tmpl.requiredTechnology)) {
+            var ents = g_Selection.toList();
+            addTrainingToQueue(ents, lst);
+        }
+        break;
+    case ACTION_GARRISON: // we garison x+1 count
+        g_Selection.reset();
+        lst.splice(x, lst.length - x)
+        g_Selection.addList(lst);
+        inputState = INPUT_PRESELECTEDACTION;
+        break;
+    case ACTION_UNGARRISON:
+        if (lst.length > 1 || x == 0) {
+            if (x >= lst.length)
+                x = lst.length - 1;
+            if (lst.length != 1 && x == 0) {
+                // unload all from all buildings
+                for each (var gh in lst)
+                    unloadAll(gh);
+            } else {
+                if (lst.length != 1)
+                    x--;
+                unloadAll(lst[x]);
+            }
+            g_Selection.reset();
+        } else {
+            lst = lst[0];
+            var state = GetEntityState(lst);
+            var gents = state.garrisonHolder.entities;
+            if (x > gents.length)
+                x = gents.length;
+            while (x--)
+                Engine.PostNetworkCommand({"type": "unload", "entities": [gents[x]], "garrisonHolder": lst});
+            // we could assign a key to follow them here
+        }
+        break;
+    case ACTION_FORMATION:
+        ents = g_Selection.toList();
+        var formationOk = Engine.GuiInterfaceCall("CanMoveEntsIntoFormation", {
+            "ents": g_Selection.toList(),
+            "formationName": lst
+        });
+        if (formationOk)
+            performFormation(ents, lst);
+        break
+    case ACTION_STANCE:
+        ents = g_Selection.toList();
+        performStance(ents, lst);
+        break;
+    case ACTION_BARTER: //TODO
+        break;
+    case ACTION_TRADER: //TODO
+        break;
+    }
+}
+
+// This returns a list of actions. Caller still has to check Technology availability
+function selectAction(player, selection)
+{
+    if (preSelectedAction == ACTION_FORMATION)
+        return Engine.GuiInterfaceCall("GetAvailableFormations");
+    else if (preSelectedAction == ACTION_STANCE)
+        return ["violent", "aggressive", "passive", "defensive", "standground"];
+
+    var ret = [];
+    for each (var ent in selection)
+    {
+        var state = GetEntityState(ent);
+        if (!state || (state.player != player && !g_DevSettings.controlAll))
+            continue;
+
+        switch (preSelectedAction)
+        {
+        case ACTION_GARRISON:
+            if (state.buildEntities || (hasClass(state, "Unit") && !hasClass(state, "Animal") && !state.garrisonHolder)) {
+                inputState = INPUT_PRESELECTEDACTION;
+                ret.push(ent);
+            }
+            break;
+        case ACTION_BUILD:
+            if (state.buildEntities && state.buildEntities.length) {
+                if (inputState != INPUT_BUILDING_PLACEMENT)
+                    inputState = INPUT_PRESELECTEDACTION;
+                return state.buildEntities;
+            }
+            break;
+        case ACTION_TRAIN:
+            if (state.production && state.production.entities.length)
+                return state.production.entities;
+            break;
+        case ACTION_UNGARRISON:
+            if (state.garrisonHolder && state.garrisonHolder.entities && state.garrisonHolder.entities.length)
+                ret.push(ent);
+            break;
+        case ACTION_BARTER:
+            if (state.barterMarket)
+                ret.push(ent);
+            break;
+        case ACTION_TRADER:
+            if (state.trader)
+                ret.push([ent, state]);
+            break;
+        }
+    }
+    return ret;
+}
+
+function getDefaultActionForSelection(player, selection)
+{
+    var action;
+    var count = 0;
+    for each (var ent in selection)
+    {
+        var state = GetEntityState(ent);
+        if (!state || (state.player != player && !g_DevSettings.controlAll))
+            continue;
+
+        if (state.buildEntities && state.buildEntities.length)
+            return ACTION_BUILD; // by default
+
+        if (state.production && state.production.entities.length)
+            action |= ACTION_TRAIN;
+        else if (!hasClass(state, "Unit") || hasClass(state, "Animal") ||
+                !state.garrisonHolder) {
+            if (++count > 1) //only works with at least two units
+                action |= ACTION_FORMATION;
+        } else if (state.barterMarket)
+            action |= ACTION_BARTER;
+        else if (state.trader)
+            action |= ACTION_TRADER;
+    }
+    if (action & ACTION_TRAIN)
+        return ACTION_TRAIN;
+    else if (action & ACTION_FORMATION)
+        return ACTION_FORMATION;
+    else if (action & ACTION_BARTER) {
+        setupUnitBarterPanel(state);
+        return ACTION_BARTER;
+    } else if (action & ACTION_TRADER) {
+        setupUnitTradingPanel(state, selection);
+        return ACTION_TRADER;
+    }
+    return 0; //shouldn't happen
 }
 
 // Performs the specified stance
@@ -1639 +1871 @@
     Engine.CameraFollow(0);
 }
 
-var lastIdleUnit = 0;
-var currIdleClass = 0;
+var lastEntity = 0;
+var currEntClass = 0;
+
+function resetEntitySearch()
+{
+    lastEntity = 0;
+    currEntClass = 0;
+}
 
-function resetIdleUnit()
+function findAllVisibleEntities(classes, mode)
 {
-    lastIdleUnit = 0;
-    currIdleClass = 0;
+    var player = Engine.GetPlayerID();
+    var plEnts = Engine.PickFriendlyEntitiesOnScreen(player);
+    // Or we could do somthing alike the below, but this is resolution dependent
+    //var plEnts = Engine.PickFriendlyEntitiesInRect(250, 250, 1400, 750, player);
+    if (!plEnts.length)
+        return;
+    var visibleEnts = [];
+    for each (cls in classes)
+    {
+        var data = {
+            entClass: cls,
+            searchMode: mode,
+            playerEnts: plEnts,
+        };
+        var entities = Engine.GuiInterfaceCall("SubsetMatchedEnts", data);
+        if (entities.length)
+            visibleEnts = visibleEnts.concat(entities);
+    }
+
+    if (visibleEnts.length) {
+        if (!getDefaultActionForSelection(player, visibleEnts).length)
+            resetPreselectedAction();
+        g_Selection.reset();
+        g_Selection.addList(visibleEnts);
+        Engine.CameraFollow(visibleEnts[0]);
+    }
 }
 
-function findIdleUnit(classes)
+// mode 0 is to search for idle, 1 to search for any
+function findEntity(classes, mode)
 {
+    var queued = Engine.HotkeyIsPressed("session.queue");
+    if (queued) {
+        findAllVisibleEntities(classes, mode)
+        return;
+    }
+    var player = Engine.GetPlayerID();
+
     // Cycle through idling classes before giving up
     for (var i = 0; i <= classes.length; ++i)
     {
-        var data = { prevUnit: lastIdleUnit, idleClass: classes[currIdleClass] };
-        var newIdleUnit = Engine.GuiInterfaceCall("FindIdleUnit", data);
-
-        // Check if we have new valid entity
-        if (newIdleUnit && newIdleUnit != lastIdleUnit)
+        var data = { prevEntity: lastEntity, entClass: classes[currEntClass], searchMode: mode};
+        var newEntity = Engine.GuiInterfaceCall("FindEntity", data);
+        if (newEntity && newEntity != lastEntity)
         {
-            lastIdleUnit = newIdleUnit;
-            g_Selection.reset()
-            g_Selection.addList([lastIdleUnit]);
-            Engine.CameraFollow(lastIdleUnit);
-
+            if (!selectAction(player, [newEntity]).length)
+                resetPreselectedAction();
+            else if (preSelectedAction == ACTION_BUILD)
+                updateBuildingPlacementPreview();
+            lastEntity = newEntity;
+            ClickSelected([newEntity], 1);
             return;
         }
-
-        lastIdleUnit = 0;
-        currIdleClass = (currIdleClass + 1) % classes.length;
+        lastEntity = 0;
+        currEntClass = (currEntClass + 1) % classes.length;
     }
-
     // TODO: display a message or play a sound to indicate no more idle units, or something
     // Reset for next cycle
-    resetIdleUnit();
+    resetEntitySearch();
 }
 
 function unload(garrisonHolder, entities)
@@ -1686 +1953 @@
 
 function unloadAll(garrisonHolder)
 {
+    var state = GetEntityState(garrisonHolder);
+    var gents = state.garrisonHolder.entities;
+    followQueue = followQueue.concat(gents);
     Engine.PostNetworkCommand({"type": "unload-all", "garrisonHolder": garrisonHolder});
 }

binaries/data/mods/public/gui/session/session.xml

@@ -85 +85 @@
     </object>
 
         <!-- Find idle warrior - TODO: Potentially move this to own UI button? -->
-    <object hotkey="selection.idlewarrior">
-        <action on="Press">findIdleUnit(["Hero", "Champion", "CitizenSoldier", "Siege", "Warship"]);</action>
-    </object>
+        <object hotkey="selection.idlewarrior">
+            <action on="Press">findEntity(["Hero", "Champion", "CitizenSoldier", "Siege", "Warship"], 1);</action>
+        </object>
+
+        <!-- Select civilcenter -->
+        <object hotkey="selection.civilcenter">
+            <action on="Press">findEntity(["CivCentre"], 0);</action>
+        </object>
+        <!-- Select market -->
+        <object hotkey="selection.market">
+            <action on="Press">findEntity(["BarterMarket", "Market", "NavalMarket"], 0);</action>
+        </object>
+        <!-- Select dropsitefood -->
+        <object hotkey="selection.dropsitefood">
+            <action on="Press">findEntity(["CivCentre", "DropsiteFood"], 0);</action>
+        </object>
+        <!-- Select dropsitewood -->
+        <object hotkey="selection.dropsiteres">
+            <action on="Press">findEntity(["CivCentre", "DropsiteWood", "DropsiteStone", "DropsiteMetal"], 0);</action>
+        </object>
+        <!-- Select structure -->
+        <object hotkey="selection.structure">
+            <action on="Press">findEntity(["Structure"], 0);</action>
+        </object>
 
     <!-- ================================  ================================ -->
     <!-- Developer / Debug items -->
@@ -527 +548 @@
             >
             <!-- TODO: should highlight the button if there's non-zero idle workers -->
             <object size="0 0 100% 100%" type="image" sprite="idleWorker" ghost="true" />
-            <action on="Press">findIdleUnit(["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"]);</action>
+            <action on="Press">findEntity(["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"], 1);</action>
             </object>
         </object>
         </object>
@@ -586 +607 @@
             </repeat>
             </object>
         </object>
-
         <!-- Stance Selection -->
         <object name="unitStancePanel"
             style="TranslucentPanel"
@@ -756 +776 @@
         <object name="unitCommandPanel"
             size="0 100%-36 100% 100%-4"
             type="image"
-            z="30"
+            z="50"
         >
             <object size="0 0 100% 100%">
             <repeat count="6">

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -1426 +1426 @@
     PlaySound(data.name, data.entity);
 };
 
-function isIdleUnit(ent, idleClass)
+GuiInterface.prototype.MatchEnt = function(ent, data)
 {
-    var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
-    var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
-    
-    // TODO: Do something with garrisoned idle units
-    return (cmpUnitAI && cmpIdentity && cmpUnitAI.IsIdle() && !cmpUnitAI.IsGarrisoned() && idleClass && cmpIdentity.HasClass(idleClass));
+    var ret;
+    var cmpId = Engine.QueryInterface(ent, IID_Identity);
+    if (cmpId && cmpId.HasClass(data.entClass)) {
+        if (data.searchMode == 0) {
+            ret = ent;
+        }  else if (data.searchMode == 1) { // Search idle villager/soldier
+            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if (cmpUnitAI && cmpUnitAI.IsIdle() && !cmpUnitAI.IsGarrisoned())
+                ret = ent;
+        }
+    }
+    return ret;
+}
+
+GuiInterface.prototype.SubsetMatchedEnts = function(player, data)
+{
+    var ret = [];
+    for each (var ent in data.playerEnts)
+    {
+        var match = this.MatchEnt(ent, data);
+        if (match)
+            ret.push(match);
+    }
+    return ret;
 }
 
-GuiInterface.prototype.FindIdleUnit = function(player, data)
+GuiInterface.prototype.FindEntity = function(player, data)
 {
     var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     var playerEntities = rangeMan.GetEntitiesByPlayer(player);
@@ -1444 +1463 @@
     // so that we cycle around in a predictable order
     for each (var ent in playerEntities)
     {
-        if (ent > data.prevUnit && isIdleUnit(ent, data.idleClass))
-            return ent;
+        if (ent > data.prevEntity)
+        {
+            var match = this.MatchEnt(ent, data);
+            if (match)
+                return match;
+        }
     }
 
-    // No idle entities left in the class
+    // No entities left in the class
     return 0;
 };
 
@@ -1571 +1594 @@
     "SetWallPlacementPreview": 1,
     "GetFoundationSnapData": 1,
     "PlaySound": 1,
-    "FindIdleUnit": 1,
+    "SubsetMatchedEnts": 1,
+    "FindEntity": 1,
     "GetTradingDetails": 1,
     "CanAttack": 1,
 

libraries/spidermonkey/include-win32/js/jstracer.h

@@ -106 +106 @@
 
     void add(T a) {
         ensure(_len + 1);
-        JS_ASSERT(_len <= _max);
+        JS_ASSERT(_len < _max);
         _data[_len++] = a;
     }
 
     void add(T* chunk, unsigned size) {
         ensure(_len + size);
-        JS_ASSERT(_len <= _max);
+        JS_ASSERT(_len < _max);
         memcpy(&_data[_len], chunk, size * sizeof(T));
         _len += size;
     }

source/graphics/GameView.cpp

@@ -728 +728 @@
             moveForward += m->ViewScrollSpeed * deltaRealTime;
     }
 
-    if (HotkeyIsPressed("camera.right"))
-        moveRightward += m->ViewScrollSpeed * deltaRealTime;
-    if (HotkeyIsPressed("camera.left"))
-        moveRightward -= m->ViewScrollSpeed * deltaRealTime;
-    if (HotkeyIsPressed("camera.up"))
-        moveForward += m->ViewScrollSpeed * deltaRealTime;
-    if (HotkeyIsPressed("camera.down"))
-        moveForward -= m->ViewScrollSpeed * deltaRealTime;
+    if (HotkeyIsPressed("camera.right")) {
+        if (HotkeyIsPressed("session.queue") && 0 /*building placement*/)
+            /* move building placement right*/;
+        else
+            moveRightward += m->ViewScrollSpeed * deltaRealTime;
+    }
+    if (HotkeyIsPressed("camera.left")) {
+        if (HotkeyIsPressed("session.queue") && 0 /*building placement*/)
+            /* move building placement left*/;
+        else
+            moveRightward -= m->ViewScrollSpeed * deltaRealTime;
+    }
+    if (HotkeyIsPressed("camera.up")) {
+        if (HotkeyIsPressed("session.queue") && 0 /*building placement*/)
+            /* move building placement up*/;
+        else
+            moveForward += m->ViewScrollSpeed * deltaRealTime;
+    }
+    if (HotkeyIsPressed("camera.down")) {
+        if (HotkeyIsPressed("session.queue") && 0 /*building placement*/)
+            /* move building placement down*/;
+        else
+            moveForward -= m->ViewScrollSpeed * deltaRealTime;
+    }
 
     if (g_Joystick.IsEnabled())
     {

source/gui/MiniMap.cpp

@@ -44 +44 @@
 
 bool g_GameRestarted = false;
 
-static unsigned int ScaleColor(unsigned int color, float x)
+static unsigned int ScaleColor(unsigned int color, unsigned int val, unsigned int div)
 {
-    unsigned int r = unsigned(float(color & 0xff) * x);
-    unsigned int g = unsigned(float((color>>8) & 0xff) * x);
-    unsigned int b = unsigned(float((color>>16) & 0xff) * x);
+    unsigned int r = (color & 0xff) * val / div;
+    unsigned int g = ((color>>8) & 0xff) * val / div;
+    unsigned int b = ((color>>16) & 0xff) * val / div;
     return (0xff000000 | r | g<<8 | b<<16);
 }
 
@@ -483 +483 @@
     u32 y = 0;
     u32 w = m_MapSize - 1;
     u32 h = m_MapSize - 1;
-    float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
+    float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight * 4.0f;
 
     m_TerrainDirty = false;
 
@@ -492 +492 @@
         u32 *dataPtr = m_TerrainData + ((y + j) * (m_MapSize - 1)) + x;
         for(u32 i = 0; i < w; i++)
         {
-            float avgHeight = ( m_Terrain->GetVertexGroundLevel((int)i, (int)j)
+            float avgHeight = m_Terrain->GetVertexGroundLevel((int)i, (int)j)
                     + m_Terrain->GetVertexGroundLevel((int)i+1, (int)j)
                     + m_Terrain->GetVertexGroundLevel((int)i, (int)j+1)
-                    + m_Terrain->GetVertexGroundLevel((int)i+1, (int)j+1)
-                ) / 4.0f;
+                    + m_Terrain->GetVertexGroundLevel((int)i+1, (int)j+1);
 
             if(avgHeight < waterHeight)
             {
@@ -525 +524 @@
                     }
                 }
 
-                *dataPtr++ = ScaleColor(color, float(val) / 255.0f);
+                *dataPtr++ = ScaleColor(color, val, 255);
             }
         }
     }