Merge branch 'fix-event-queue-interrupt'

Author: flemming-n-larsen

.gitignore

@@ -19,6 +19,9 @@ bin/
 obj/
 generated/
 
+/bot-api/dotnet/docs/ReadMe.md
+/bot-api/dotnet/docs/Release-notes.txt
+
 *.iml
 
 /games.properties

VERSIONS.MD

@@ -1,11 +1,15 @@
-## 📦 0.24.5
+## 📦 0.25.0 - Fix for Ranks and Event Queue improvements - 11-Oct-2024
 
 #### 🐞 Bug Fixes
 
 - Server:
     - #108: The ranks were wrong as they did not reflect the total score and placements 
+- Bot API:
+    - An interruptible event was not interrupted when `setInterruptible(true)` was called. The event queue contained
+      more bot events than it should, due to this bug.
+    - The event queue and dispatcher was improved so it is closer to the implementation for the original Robocode. 
 
-## 📦 0.24.4 - Support for IPv6 endpoints
+## 📦 0.24.4 - Support for IPv6 endpoints - 19-Sep-2024
 
 #### Improvements
 

bot-api/dotnet/Robocode.TankRoyale.BotApi/src/events/BotEvent.cs

@@ -5,20 +5,7 @@
 /// </summary>
 public abstract class BotEvent : IEvent
 {
-    /// <summary>Turn number when the event occurred.</summary>
     public int TurnNumber { get; }
-
-    /// <summary>
-    /// Indicates if this event is critical, and hence should not be removed from event queue when it gets old.
-    /// </summary>
-    /// <return>
-    /// <c>true</c> if this event is critical; <c>false</c> otherwise. Default is <c>false</c>.
-    /// </return>
     public virtual bool IsCritical => false;
-
-    ///<summary>
-    /// Initializes a new instance of the Event class.
-    ///</summary>
-    ///<param name="turnNumber">Is the turn number when the event occurred.</param>
     protected BotEvent(int turnNumber) => TurnNumber = turnNumber;
 }

bot-api/dotnet/Robocode.TankRoyale.BotApi/src/internal/BaseBotInternals.cs

@@ -37,7 +37,7 @@ public sealed class BaseBotInternals
     private GameSetup gameSetup;
 
     private InitialPosition initialPosition;
-    
+
     private E.TickEvent tickEvent;
     private long? ticksStart;
 
@@ -71,6 +71,8 @@ public sealed class BaseBotInternals
 
     private ICollection<int> teammateIds;
 
+    private int lastExecuteTurnNumber;
+
     internal BaseBotInternals(IBaseBot baseBot, BotInfo botInfo, Uri serverUrl, string serverSecret)
     {
         this.baseBot = baseBot;
@@ -103,7 +105,7 @@ private void RedirectStdOutAndStdErr()
     {
         recordingStdOut = new RecordingTextWriter(Console.Out);
         recordingStdErr = new RecordingTextWriter(Console.Error);
-        
+
         Console.SetOut(recordingStdOut);
         Console.SetError(recordingStdErr);
     }
@@ -166,12 +168,12 @@ public void EnableEventHandling(bool enable)
         eventHandlingDisabledTurn = enable ? 0 : CurrentTickOrThrow.TurnNumber;
     }
 
-    public bool IsEventHandlingDisabled()
+    private bool IsEventHandlingDisabled()
     {
         // Important! Allow an additional turn so events like RoundStarted can be handled
         return eventHandlingDisabledTurn != 0 && eventHandlingDisabledTurn < (CurrentTickOrThrow.TurnNumber - 1);
     }
-    
+
     public void SetStopResumeHandler(IStopResumeListener listener) => stopResumeListener = listener;
 
     private static S.BotIntent NewBotIntent() => new()
@@ -208,6 +210,7 @@ private void OnRoundStarted(E.RoundStartedEvent e)
         eventQueue.Clear();
         IsStopped = false;
         eventHandlingDisabledTurn = 0;
+        lastExecuteTurnNumber = -1;
     }
 
     private void OnNextTurn(E.TickEvent e)
@@ -258,6 +261,12 @@ internal void Execute()
             return;
 
         var turnNumber = CurrentTickOrThrow.TurnNumber;
+        if (turnNumber == lastExecuteTurnNumber)
+        {
+            return; // skip this execute, as we have already run this method within the same turn
+        }
+
+        lastExecuteTurnNumber = turnNumber;
 
         DispatchEvents(turnNumber);
         SendIntent();
@@ -278,6 +287,7 @@ private void TransferStdOutToBotIntent()
             var output = recordingStdOut.ReadNext();
             BotIntent.StdOut = output.Length > 0 ? output : null;
         }
+
         if (recordingStdErr != null)
         {
             var error = recordingStdErr.ReadNext();
@@ -312,6 +322,11 @@ private void DispatchEvents(int turnNumber)
         }
         catch (Exception e)
         {
+            if (e is InterruptEventHandlerException)
+            {
+                return;
+            }
+
             Console.Error.WriteLine(e);
         }
     }
@@ -328,8 +343,6 @@ private void DispatchEvents(int turnNumber)
 
     internal E.TickEvent CurrentTickOrThrow => tickEvent ?? throw new BotException(TickNotAvailableMsg);
 
-    internal E.TickEvent CurrentTickOrNull => tickEvent;
-
     private long TicksStart
     {
         get
@@ -638,12 +651,12 @@ internal void SendTeamMessage(int? teammateId, object message)
 
     internal int GetPriority(Type eventType)
     {
-        if (!eventPriorities.ContainsKey(eventType))
+        if (!eventPriorities.TryGetValue(eventType, out var priority))
         {
             throw new InvalidOperationException($"Could not get event priority for the type: {eventType.Name}");
         }
 
-        return eventPriorities[eventType];
+        return priority;
     }
 
     internal void SetPriority(Type eventType, int priority) => eventPriorities[eventType] = priority;

bot-api/dotnet/Robocode.TankRoyale.BotApi/src/internal/EventQueue.cs

@@ -32,7 +32,6 @@ internal void Clear()
     {
         events = events.Clear();
         baseBotInternals.Conditions.Clear(); // conditions might be added in the bots Run() method each round
-        currentTopEvent = null;
         currentTopEventPriority = MinValue;
     }
 
@@ -71,25 +70,46 @@ internal void AddEventsFromTick(TickEvent tickEvent)
 
     internal void DispatchEvents(int turnNumber)
     {
+//        DumpEvents(); // for debugging purposes
+
         RemoveOldEvents(turnNumber);
         SortEvents();
 
         while (IsBotRunning)
         {
-            var botEvent = GetNextEvent();
-            if (botEvent == null || IsSameEventAndInterruptible(botEvent))
+            BotEvent currentEvent = GetNextEvent();
+            if (currentEvent == null) {
+                break;
+            }
+            if (IsSameEvent(currentEvent))
+            {
+                if (IsInterruptible)
+                {
+                    SetInterruptible(currentEvent.GetType(), false); // clear interruptible flag
+
+                    // We are already in an event handler, took action, and a new event was generated.
+                    // So we want to break out of the old handler to process the new event here.
+                    throw new InterruptEventHandlerException();
+                }
                 break;
+            }
 
-            var priority = GetPriority(botEvent);
-            var originalTopEventPriority = currentTopEventPriority;
+            int oldTopEventPriority = currentTopEventPriority;
 
-            currentTopEventPriority = priority;
-            currentTopEvent = botEvent;
+            currentTopEventPriority = GetPriority(currentEvent);
+            currentTopEvent = currentEvent;
 
-            try {
-                HandleEvent(botEvent, turnNumber);
-            } finally {
-                currentTopEventPriority = originalTopEventPriority;
+            try
+            {
+                HandleEvent(currentEvent, turnNumber);
+            }
+            catch (InterruptEventHandlerException)
+            {
+                // Expected when event handler is interrupted on purpose
+            }
+            finally
+            {
+                currentTopEventPriority = oldTopEventPriority;
             }
         }
     }
@@ -117,19 +137,27 @@ private BotEvent GetNextEvent()
         return botEvent;
     }
 
-    private bool IsSameEventAndInterruptible(BotEvent botEvent) =>
-        GetPriority(botEvent) == currentTopEventPriority && (currentTopEventPriority > MinValue && IsInterruptible);
+    private bool IsSameEvent(BotEvent botEvent) =>
+        GetPriority(botEvent) == currentTopEventPriority;
 
     private int GetPriority(BotEvent botEvent)
     {
         return baseBotInternals.GetPriority(botEvent.GetType());
     }
 
-    private void HandleEvent(BotEvent botEvent, int turnNumber) {
-        if (IsNotOldOrIsCriticalEvent(botEvent, turnNumber)) {
-            botEventHandlers.Fire(botEvent);
+    private void HandleEvent(BotEvent botEvent, int turnNumber)
+    {
+        try
+        {
+            if (IsNotOldOrIsCriticalEvent(botEvent, turnNumber))
+            {
+                botEventHandlers.Fire(botEvent);
+            }
+        }
+        finally
+        {
+            SetInterruptible(botEvent.GetType(), false); // clear interruptible flag
         }
-        SetInterruptible(botEvent.GetType(), false);
     }
 
     public int Compare(BotEvent botEvent1, BotEvent botEvent2)
@@ -154,27 +182,25 @@ public int Compare(BotEvent botEvent1, BotEvent botEvent2)
 
     private static bool IsNotOldOrIsCriticalEvent(BotEvent botEvent, int turnNumber)
     {
-        var isNotOld = botEvent.TurnNumber + MaxEventAge >= turnNumber;
-        var isCritical = botEvent.IsCritical;
-        return isNotOld || isCritical;
+        var isNotOld = botEvent.TurnNumber >= turnNumber - MaxEventAge;
+        return isNotOld || botEvent.IsCritical;
     }
 
     private static bool IsOldAndNonCriticalEvent(BotEvent botEvent, int turnNumber)
     {
-        var isOld = botEvent.TurnNumber + MaxEventAge < turnNumber;
-        var isNonCritical = !botEvent.IsCritical;
-        return isOld && isNonCritical;
+        var isOld = botEvent.TurnNumber < turnNumber - MaxEventAge;
+        return isOld && !botEvent.IsCritical;
     }
 
     private void AddEvent(BotEvent botEvent)
     {
-        if (events.Count > MaxQueueSize)
+        if (events.Count <= MaxQueueSize)
         {
-            Console.Error.WriteLine("Maximum event queue size has been reached: " + MaxQueueSize);
+            events = events.Add(botEvent);
         }
         else
         {
-            events = events.Add(botEvent);
+            Console.Error.WriteLine("Maximum event queue size has been reached: " + MaxQueueSize);
         }
     }
 
@@ -185,4 +211,10 @@ private void AddCustomEvents()
             AddEvent(new CustomEvent(baseBotInternals.CurrentTickOrThrow.TurnNumber, condition));
         }
     }
+
+    private void DumpEvents()
+    {
+        string eventsString = string.Join(", ", events.Select(e => $"{e.GetType().Name}({e.TurnNumber})"));
+        Console.WriteLine($"events: {eventsString}");
+    }
 }

bot-api/dotnet/Robocode.TankRoyale.BotApi/src/internal/InterruptEventHandlerException.cs

@@ -0,0 +1,6 @@
+namespace Robocode.TankRoyale.BotApi.Internal;
+
+// Exception used for interrupting event handlers.
+public class InterruptEventHandlerException : System.Exception
+{
+}

bot-api/dotnet/build.gradle.kts

@@ -83,15 +83,15 @@ tasks {
     }
 
     register("pushLocal") {
-        dependsOn(build)
+        dependsOn(build, prepareNugetDocs)
 
         doLast {
             val userhome = System.getenv("USERPROFILE") ?: System.getenv("HOME")
             println("$userhome/.nuget/packages/${artifactName.toLowerCaseAsciiOnly()}/$version")
             delete("$userhome/.nuget/packages/${artifactName.toLowerCaseAsciiOnly()}/$version")
             exec {
                 workingDir("Robocode.TankRoyale.BotApi/bin/Release")
-                commandLine("dotnet", "nuget", "push", "$artifactName.$version.nupkg", "-s", "local")
+                commandLine("dotnet", "nuget", "push", "$artifactName.$version.nupkg", "--source", "$userhome/.nuget/packages")
             }
         }
     }

bot-api/java/src/main/java/dev/robocode/tankroyale/botapi/internal/BaseBotInternals.java

@@ -113,6 +113,8 @@ public final class BaseBotInternals {
 
     private final Map<Class<? extends BotEvent>, Integer> eventPriorities = initializeEventPriorities();
 
+    private int lastExecuteTurnNumber;
+
     public BaseBotInternals(IBaseBot baseBot, BotInfo botInfo, URI serverUrl, String serverSecret) {
         this.baseBot = baseBot;
         this.botInfo = (botInfo == null) ? EnvVars.getBotInfo() : botInfo;
@@ -252,6 +254,7 @@ private void onRoundStarted(RoundStartedEvent e) {
         eventQueue.clear();
         isStopped = false;
         eventHandlingDisabledTurn = 0;
+        lastExecuteTurnNumber = -1;
     }
 
     private void onNextTurn(TickEvent e) {
@@ -299,6 +302,10 @@ public void execute() {
             return;
 
         final var turnNumber = getCurrentTickOrThrow().getTurnNumber();
+        if (turnNumber == lastExecuteTurnNumber) {
+            return; // skip this execute, as we have already run this method within the same turn
+        }
+        lastExecuteTurnNumber = turnNumber;
 
         dispatchEvents(turnNumber);
         sendIntent();