Merge remote-tracking branch 'origin/ChopperSupport' into ChopperSupport

Author: pops64

config/VehicleConfigurations.xml

@@ -234,7 +234,7 @@ You can define the following custom settings:
 	/>
     <Vehicle name="titan18.xml"
              noReverse="true"
-             turnRadius = "9"
+             turnRadius = "7.5"
              implementWheelAlwaysOnGround = "true"
              raiseLate = "true"
              lowerEarly = "true"
@@ -353,7 +353,7 @@ You can define the following custom settings:
     <Vehicle name="pw10012.xml"
              noReverse = "true"
              implementWheelAlwaysOnGround = "true"
-             turnRadius = "14"
+             turnRadius = "7.5"
              raiseLate = "true"
              lowerEarly = "true"
     />
@@ -403,8 +403,7 @@ You can define the following custom settings:
     <!--Implements-->
     <!--Mod: Gregoire Besson SPSL9 -->
     <Vehicle name="spsl9.xml"
-             toolOffsetX = "2.1"
-             turnRadius = "12"
+             turnRadius = "7.5"
              implementWheelAlwaysOnGround = "true"
 			 workingWidth = "10.5"
              noReverse = "true"

scripts/ai/AIDriveStrategyCombineCourse.lua

@@ -1308,15 +1308,15 @@ function AIDriveStrategyCombineCourse:getTurnCourse()
 end
 
 function AIDriveStrategyCombineCourse:startTurn(ix)
-    self:debug('Starting a combine turn.')
+    self:debug('    Starting a combine turn.')
 
     self.turnContext = TurnContext(self.vehicle, self.course, ix, ix + 1, self.turnNodes, self:getWorkWidth(),
             self.frontMarkerDistance, self.backMarkerDistance,
             self:getTurnEndSideOffset(), self:getTurnEndForwardOffset())
 
     -- Combines drive special headland corner maneuvers, except potato and sugar beet harvesters
     if self.turnContext:isHeadlandCorner() then
-        if self:isPotatoOrSugarBeetHarvester() then
+        if self.combineController:isPotatoOrSugarBeetHarvester() then
             self:debug('Headland turn but this harvester uses normal turn maneuvers.')
             AIDriveStrategyCombineCourse.superClass().startTurn(self, ix)
         elseif self.course:isOnConnectingTrack(ix) then
@@ -1446,16 +1446,6 @@ function AIDriveStrategyCombineCourse:isDischarging()
     return self.pipeController:isDischarging()
 end
 
-function AIDriveStrategyCombineCourse:isPotatoOrSugarBeetHarvester()
-    for i, fillUnit in ipairs(self.vehicle:getFillUnits()) do
-        if self.vehicle:getFillUnitSupportsFillType(i, FillType.POTATO) or
-                self.vehicle:getFillUnitSupportsFillType(i, FillType.SUGARBEET) then
-            self:debug('This is a potato or sugar beet harvester.')
-            return true
-        end
-    end
-    return false
-end
 
 -----------------------------------------------------------------------------------------------------------------------
 --- Self unload

scripts/ai/AIDriveStrategyCourse.lua

@@ -37,6 +37,11 @@ AIDriveStrategyCourse.onFinishedEvent = "onFinished"
 AIDriveStrategyCourse.onStartEvent = "onStart"
 AIDriveStrategyCourse.updateEvent = "update"
 AIDriveStrategyCourse.deleteEvent = "delete"
+--- A row has just been finished, implements are being raised and about to start the actual turn
+AIDriveStrategyCourse.onFinishRowEvent = "onFinishRow"
+--- The actual turn is done, now we are starting into the row and will lower the implements when
+--- they reach the start of the row
+AIDriveStrategyCourse.onTurnEndProgressEvent = "onTurnEndProgress"
 
 function AIDriveStrategyCourse.new(customMt)
     if customMt == nil then

scripts/ai/AIDriveStrategyPlowCourse.lua

@@ -168,4 +168,13 @@ end
 function AIDriveStrategyPlowCourse:updateFieldworkOffset(course)
 	--- Ignore the tool offset setting.
 	course:setOffset((self.aiOffsetX or 0), (self.aiOffsetZ or 0))
+end
+
+--- When we return from a turn, the offset is reverted and should immediately set, not waiting
+--- for the first waypoint to pass as it is on the wrong side right after the turn
+function AIDriveStrategyPlowCourse:resumeFieldworkAfterTurn(ix)
+    -- call twice to trick the smoothing and reach the desired value sooner.
+    self:updatePlowOffset()
+    self:updatePlowOffset()
+    AIDriveStrategyPlowCourse.superClass().resumeFieldworkAfterTurn(self, ix)
 end

scripts/ai/controllers/CombineController.lua

@@ -124,3 +124,14 @@ function CombineController:isDroppingStrawSwath()
     return self.combineSpec.strawPSenabled
 end
 
+function CombineController:isPotatoOrSugarBeetHarvester()
+    for i, fillUnit in ipairs(self.implement:getFillUnits()) do
+        if self.implement:getFillUnitSupportsFillType(i, FillType.POTATO) or
+                self.implement:getFillUnitSupportsFillType(i, FillType.SUGARBEET) then
+            self:debug('This is a potato or sugar beet harvester.')
+            return true
+        end
+    end
+    return false
+end
+

scripts/ai/controllers/ImplementController.lua

@@ -87,6 +87,12 @@ function ImplementController:onFinished()
     --- override
 end
 
+function ImplementController:onFinishRow(isHeadlandTurn)
+end
+
+function ImplementController:onTurnEndProgress(workStartNode, isLeftTurn)
+end
+
 --- Any object this controller wants us to ignore, can register here a callback at the proximity controller
 function ImplementController:registerIgnoreProximityObjectCallback(proximityController)
 

scripts/ai/controllers/PlowController.lua

@@ -66,10 +66,57 @@ function PlowController:getIsPlowRotationAllowed()
     return self.implement:getIsPlowRotationAllowed()
 end
 
+function PlowController:isFullyRotated()
+    local rotationAnimationTime = self.implement:getAnimationTime(self.plowSpec.rotationPart.turnAnimation)
+    return rotationAnimationTime < 0.001 or rotationAnimationTime > 0.999
+end
+
 --- Rotates the plow if possible.
 ---@param shouldBeOnTheLeft boolean|nil
 function PlowController:rotate(shouldBeOnTheLeft)
     if self:isRotatablePlow() and self:getIsPlowRotationAllowed() then
         self.implement:setRotationMax(shouldBeOnTheLeft)
     end
+end
+
+--- We rotate plows in 180º turns to the center so we can turn on a smaller radius. This is
+--- triggered by the onFinishRow and onTurnEndProgress controller events emitted by all
+--- CourseTurn and derived turns.
+--- With the Giants helper, plows are rotated by the onAIFieldWorkerTurnProgress event which
+--- we now only use in the KTurn (only 3-point hitch mounted plows use the KTurn, so all
+--- plow turns are covered)
+
+--- This is called once when the row is finished and the turn is just about to start.
+--- Rotate the plow to the center position to allow for smaller turn radius (when not rotated,
+--- the tractor's back wheel touching the plow won't let us turn sharp enough, and thus
+--- using a lot of real estate for a turn.
+---@param isHeadlandTurn boolean true if this is a headland turn
+function PlowController:onFinishRow(isHeadlandTurn)
+    -- no need to rotate to center on headland turns
+    if self:isRotatablePlow() and not isHeadlandTurn then
+        self.implement:setRotationCenter()
+    end
+end
+
+--- This is called in every loop when we approach the start of the row, the location where
+--- the plow must be lowered. Currently AIDriveStrategyFieldworkCourse takes care of the lowering,
+--- here we only make sure that the plow is rotated to the work position (from the center position)
+--- in time.
+---@param workStartNode number node where the work starts as calculated by TurnContext
+---@param isLeftTurn boolean is this a left turn?
+function PlowController:onTurnEndProgress(workStartNode, isLeftTurn)
+    if self:isRotatablePlow() and not self:isFullyRotated() and not self:isRotationActive() then
+        -- more or less aligned with the first waypoint of the row, start rotating to working position
+        if CpMathUtil.isSameDirection(self.implement.rootNode, workStartNode, 30) then
+            self.implement:setRotationMax(isLeftTurn)
+        end
+    end
+end
+
+function PlowController:canContinueWork()
+    if self:isRotatablePlow() then
+        return self:isFullyRotated()
+    else
+        return true
+    end
 end

scripts/ai/turns/AITurn.lua

@@ -246,6 +246,7 @@ function AITurn:finishRow(dt)
     -- keep driving straight until we need to raise our implements
     if self.driveStrategy:shouldRaiseImplements(self:getRaiseImplementNode()) then
         self.driveStrategy:raiseImplements()
+        self.driveStrategy:raiseControllerEvent(AIDriveStrategyCourse.onFinishRowEvent, self.turnContext:isHeadlandCorner())
         self:debug('Row finished, starting turn.')
         self:startTurn()
     end
@@ -307,16 +308,12 @@ end
 function KTurn:startTurn()
     AITurn.startTurn(self)
     self.state = self.states.FORWARD
-    self.vehicle:raiseAIEvent("onAIFieldWorkerTurnProgress", "onAIImplementTurnProgress", 0, self.turnContext:isLeftTurn())
-    self:debug('Turn progress 0')
 end
 
 function KTurn:turn(dt)
     -- we end the K turn with a temporary course leading straight into the next row. During this turn the
     -- AI driver's state remains TURNING and thus calls AITurn:drive() which wil take care of raising the implements
     local endTurn = function(course)
-        self:debug('Turn progress 100')
-        self.vehicle:raiseAIEvent("onAIFieldWorkerTurnProgress", "onAIImplementTurnProgress", 100, self.turnContext:isLeftTurn())
         self.state = self.states.ENDING_TURN
         self.ppc:setCourse(course)
         self.ppc:initialize(1)
@@ -346,7 +343,7 @@ function KTurn:turn(dt)
                 endTurn(self.endingTurnCourse)
             else
                 -- reverse until we can make turn to the turn end point
-                self.vehicle:raiseAIEvent("onAIFieldWorkerTurnProgress", "onAIImplementTurnProgress", 50, self.turnContext:isLeftTurn())
+                self.vehicle:raiseAIEvent("onAIFieldWorkerTurnProgress", "onAIImplementTurnProgress", 0.5, self.turnContext:isLeftTurn())
                 self:debug('Turn progress 50')
                 self.state = self.states.REVERSE
                 self.endingTurnCourse = TurnEndingManeuver(self.vehicle, self.turnContext,
@@ -573,8 +570,6 @@ function CourseTurn:turn()
 
     local gx, gz, moveForwards, maxSpeed = AITurn.turn(self)
 
-    self:updateTurnProgress()
-
     self:changeDirectionWhenAligned()
     self:changeToFwdWhenWaypointReached()
 
@@ -589,6 +584,8 @@ end
 ---@return boolean true if it is ok the continue driving, false when the vehicle should stop
 function CourseTurn:endTurn(dt)
     -- keep driving on the turn course until we need to lower our implements
+    self.driveStrategy:raiseControllerEvent(AIDriveStrategyCourse.onTurnEndProgressEvent,
+            self.turnContext.workStartNode, self.turnContext:isLeftTurn())
     local shouldLower, dz = self.driveStrategy:shouldLowerImplements(self.turnContext.workStartNode, self.ppc:isReversing())
     if shouldLower then
         if not self.implementsLowered then
@@ -605,7 +602,7 @@ function CourseTurn:endTurn(dt)
             -- for those people who set insanely high turn speeds...
             local implementCheckDistance = math.max(1, 0.1 * self.vehicle:getLastSpeed())
             if dz and dz > -implementCheckDistance then
-                if self.vehicle:getCanAIFieldWorkerContinueWork() then
+                if self.driveStrategy:getCanContinueWork() then
                     self:debug("implements lowered, resume fieldwork")
                     self:resumeFieldworkAfterTurn(self.turnContext.turnEndWpIx)
                 else
@@ -620,21 +617,6 @@ function CourseTurn:endTurn(dt)
     return true
 end
 
-function CourseTurn:updateTurnProgress()
-    if self.turnCourse and not self.turnContext:isHeadlandCorner() then
-        -- turn progress is for example rotating plows, no need to worry about that during headland turns
-        local progress = self.turnCourse:getCurrentWaypointIx() / self.turnCourse:getNumberOfWaypoints()
-        if (progress - (self.lastProgress or 0)) > 0.1 then
-            -- just send 0 and 1 as it looks like some plows won't turn fully if they receive something in between
-            -- also, start turning a bit before we reach the middle of the turn to make sure it is ready
-            local progressToSend = progress <= 0.3 and 0 or 1
-            self.vehicle:raiseAIEvent("onAIFieldWorkerTurnProgress", "onAIImplementTurnProgress", progressToSend, self.turnContext:isLeftTurn())
-            self:debug('progress %.1f (left: %s)', progressToSend, self.turnContext:isLeftTurn())
-            self.lastProgress = progress
-        end
-    end
-end
-
 function CourseTurn:onWaypointChange(ix)
     AITurn.onWaypointChange(self, ix)
     if self.turnCourse then
@@ -967,10 +949,6 @@ function FinishRowOnly:startTurn()
     end
 end
 
-function FinishRowOnly:updateTurnProgress()
-    -- do nothing since this isn't really a turn
-end
-
 --- A turn which really isn't a turn just a course to start a field work row using the supplied course and
 --- making sure we start working at the start point defined by the turn context with all implements lowered in time.
 --- This does not actually drive the course like the other AITurn derivates to keep full control in the strategy
@@ -1045,7 +1023,7 @@ function StartRowOnly:getDriveData()
         -- for those people who set insanely high turn speeds...
         local implementCheckDistance = math.max(1, 0.1 * self.vehicle:getLastSpeed())
         if dz and dz > -implementCheckDistance then
-            if self.vehicle:getCanAIFieldWorkerContinueWork() then
+            if self.driveStrategy:getCanContinueWork() then
                 self:debug("implements lowered, resume fieldwork")
                 self:resumeFieldworkAfterTurn(self.turnContext.turnEndWpIx)
             else