Sleeping negative delay

Content.Tests/Content.Tests.csproj

@@ -43,6 +43,12 @@
     <DMStandard Include="..\DMCompiler\DMStandard\**" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Include="DMProject\Tests\Sleeping\Basic.cs" />
+    <Content Include="DMProject\Tests\Sleeping\Basic.dm" />
+    <Content Include="dmproject\tests\sleeping\YieldOrder.dm" />
+  </ItemGroup>
+
   <Target Name="CopyDMStandard" AfterTargets="AfterBuild">
     <Copy SourceFiles="@(DMStandard)" DestinationFiles="@(DMStandard->'$(OutDir)\DMStandard\%(RecursiveDir)%(Filename)%(Extension)')" />
   </Target>

Content.Tests/ContentUnitTest.cs

@@ -4,8 +4,8 @@
 using OpenDreamClient;
 using OpenDreamRuntime;
 using OpenDreamRuntime.Map;
+using OpenDreamRuntime.Procs;
 using OpenDreamRuntime.Rendering;
-using OpenDreamShared;
 using OpenDreamShared.Rendering;
 using Robust.Shared.Analyzers;
 using Robust.Shared.IoC;
@@ -24,11 +24,10 @@ public class ContentUnitTest : RobustUnitTest {
     protected override void OverrideIoC() {
         base.OverrideIoC();
 
-        SharedOpenDreamIoC.Register();
-
         if (Project == UnitTestProject.Server) {
             ServerContentIoC.Register(unitTests: true);
             IoCManager.Register<IDreamMapManager, DummyDreamMapManager>();
+            IoCManager.Register<IOpenDreamGameTiming, DummyOpenDreamGameTiming>();
         } else if (Project == UnitTestProject.Client) {
             ClientContentIoC.Register();
         }

Content.Tests/DMProject/Tests/Sleeping/Basic.dm

@@ -0,0 +1,20 @@
+// RETURN TRUE
+
+var/should_be_set = FALSE
+
+/proc/RunTest()
+    ASSERT(world.time == 0)
+    sleep(world.tick_lag)
+    ASSERT(world.time == 1)
+    sleep(10)
+    ASSERT(world.time == 11)
+    StackCheck()
+    ASSERT(world.time == 61)
+    ASSERT(should_be_set)
+    return TRUE
+
+/proc/StackCheck()
+    ASSERT(world.time == 11)
+    sleep(50)
+    ASSERT(world.time == 61)
+    should_be_set = TRUE

Content.Tests/DMProject/Tests/Sleeping/YieldOrder.dm

@@ -0,0 +1,58 @@
+var/counter
+#define ExpectOrder(n) ASSERT(++counter == ##n)
+
+/proc/BackgroundSleep(delay, expect)
+	set waitfor = FALSE
+	sleep(delay)
+	world.log << "Expect: [expect]"
+	ExpectOrder(expect)
+
+#define MODE_INLINE 0 // spawn
+#define MODE_BACKGROUND 1 // set waitfor = FALSE + sleep
+#define MODE_RAND 2 // random seeded
+
+#define TestSleep(delay, expect) if(mode == MODE_INLINE || (mode == MODE_RAND && prob(50))){ spawn(##delay) { ExpectOrder(##expect); } } else { BackgroundSleep(##delay, ##expect); }
+
+/proc/TestSequence(mode)
+	counter = 0
+	var/start_tick = world.time
+
+	TestSleep(0, 2)
+	ExpectOrder(1)
+	sleep(0)
+	ExpectOrder(3)
+
+	TestSleep(-1, 4)
+	ExpectOrder(5)
+
+	TestSleep(0, 11)
+	sleep(-1)
+	ExpectOrder(6)
+
+	TestSleep(-1, 7)
+	ExpectOrder(8)
+	sleep(-1)
+	ExpectOrder(9)
+
+	TestSleep(1, 13)
+	sleep(-1)
+	ExpectOrder(10)
+	sleep(0)
+	ExpectOrder(12)
+
+	ASSERT(world.time == start_tick)
+
+	sleep(1)
+	ExpectOrder(14)
+
+/proc/RunTest()
+	world.log << "Inline:"
+	TestSequence(MODE_INLINE)
+
+	world.log << "Background:"
+	TestSequence(MODE_BACKGROUND)
+
+	rand_seed(22475)
+	for(var/i in 1 to 10000)
+		world.log << "Rand-[i]:"
+		TestSequence(MODE_RAND)

Content.Tests/DMTests.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DMCompiler.Compiler;
 using NUnit.Framework;
 using OpenDreamRuntime;
 using OpenDreamRuntime.Objects;
+using OpenDreamRuntime.Procs;
 using Robust.Shared.Asynchronous;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -21,10 +23,14 @@ public sealed partial class DMTests : ContentUnitTest {
     private const string InitializeEnvironment = "./environment.dme";
     private const string TestsDirectory = "Tests";
 
+    [Dependency] IOpenDreamGameTiming _gameTiming = default!;
     [Dependency] private readonly DreamManager _dreamMan = default!;
     [Dependency] private readonly DreamObjectTree _objectTree = default!;
+    [Dependency] private readonly ProcScheduler _procScheduler = default!;
     [Dependency] private readonly ITaskManager _taskManager = default!;
 
+    DummyOpenDreamGameTiming GameTiming => (DummyOpenDreamGameTiming)_gameTiming;
+
     [Flags]
     public enum DMTestFlags {
         NoError = 0,        // Should run without errors
@@ -81,17 +87,23 @@ public void TestFiles(string sourceFile, DMTestFlags testFlags, int errorCode) {
                 return;
             }
 
+            _procScheduler.ClearState();
+            GameTiming.CurTick = GameTick.Zero;
+
             Assert.That(compiledFile is not null && File.Exists(compiledFile), "Failed to compile DM source file");
             Assert.That(_dreamMan.LoadJson(compiledFile), $"Failed to load {compiledFile}");
             _dreamMan.LastDMException = null; // Nuke any exception from a prior test
             _dreamMan.StartWorld();
 
             (bool successfulRun, DreamValue? returned, Exception? exception) = RunTest();
 
+            int expectedThreads;
             if (testFlags.HasFlag(DMTestFlags.NoReturn)) {
                 Assert.That(returned.HasValue, Is.False, "proc returned unexpectedly");
+                expectedThreads = 1;
             } else {
                 Assert.That(returned.HasValue, "proc did not return (did it hit an exception?)");
+                expectedThreads = 0;
             }
 
             if (testFlags.HasFlag(DMTestFlags.RuntimeError)) {
@@ -107,6 +119,9 @@ public void TestFiles(string sourceFile, DMTestFlags testFlags, int errorCode) {
                 Assert.That(returned?.IsTruthy(), Is.True, "Test was expected to return TRUE");
             }
 
+            var threads = _procScheduler.InspectThreads().ToList();
+            Assert.That(threads.Count == expectedThreads && !_procScheduler.HasProcsSleeping && !_procScheduler.HasProcsQueued, $"One or more threads did not finish!");
+
             // Due to how softdels work we need to make sure we clean up /now/.
             GC.Collect();
             _dreamMan.Update();
@@ -137,11 +152,12 @@ public void TestFiles(string sourceFile, DMTestFlags testFlags, int errorCode) {
         watch.Start();
 
         // Tick until our inner call has finished
-        while (!callTask.IsCompleted) {
+        while (!callTask.IsCompleted || _procScheduler.HasProcsQueued || _procScheduler.HasProcsSleeping) {
             _dreamMan.Update();
             _taskManager.ProcessPendingTasks();
+            GameTiming.CurTick = new GameTick(_gameTiming.CurTick.Value + 1);
 
-            if (watch.Elapsed.TotalMilliseconds > 500) {
+            if (GameTiming.CurTick.Value > 50000) {
                 Assert.Fail("Test timed out");
             }
         }

Content.Tests/DummyOpenDreamGameTiming.cs

@@ -0,0 +1,26 @@
+using OpenDreamRuntime.Procs;
+
+using Robust.Shared.IoC;
+using Robust.Shared.Timing;
+
+using System;
+
+namespace Content.Tests {
+    sealed class DummyOpenDreamGameTiming : IOpenDreamGameTiming {
+
+        [Dependency] IGameTiming _gameTiming = null!;
+
+        public GameTick CurTick { get; set; }
+
+        public TimeSpan LastTick => _gameTiming.LastTick;
+
+        public TimeSpan RealTime => _gameTiming.RealTime;
+
+        public TimeSpan TickPeriod => _gameTiming.TickPeriod;
+
+        public ushort TickRate {
+            get => _gameTiming.TickRate;
+            set => _gameTiming.TickRate = value;
+        }
+    }
+}

DMCompiler/Bytecode/DreamProcOpcode.cs

@@ -307,6 +307,10 @@
     NPushFloatAssign = 0x9B,
     [OpcodeMetadata(0, OpcodeArgType.ArgType, OpcodeArgType.StackDelta)]
     Animate = 0x9C,
+    [OpcodeMetadata(-1)]
+    Sleep = 0x9D,
+    [OpcodeMetadata(0)]
+    BackgroundSleep = 0x9E,
 }
 // ReSharper restore MissingBlankLines
 

DMCompiler/Compiler/DM/AST/DMAST.ProcStatements.cs

@@ -91,6 +91,12 @@ public sealed class DMASTProcStatementSet(
     public readonly bool WasInKeyword = wasInKeyword; // Marks whether this was a "set x in y" expression, or a "set x = y" one
 }
 
+public sealed class DMASTProcStatementSleep(
+    Location location,
+    DMASTExpression delay) : DMASTProcStatement(location) {
+    public DMASTExpression Delay = delay;
+}
+
 public sealed class DMASTProcStatementSpawn(Location location, DMASTExpression delay, DMASTProcBlockInner body)
     : DMASTProcStatement(location) {
     public DMASTExpression Delay = delay;

DMCompiler/Compiler/DM/DMLexer.cs

@@ -55,6 +55,7 @@ public sealed class DMLexer : TokenLexer {
         { "set", TokenType.DM_Set },
         { "call", TokenType.DM_Call },
         { "call_ext", TokenType.DM_Call},
+        { "sleep", TokenType.DM_Sleep },
         { "spawn", TokenType.DM_Spawn },
         { "goto", TokenType.DM_Goto },
         { "step", TokenType.DM_Step },

DMCompiler/Compiler/DM/DMParser.cs

@@ -90,6 +90,7 @@
             TokenType.DM_Throw,
             TokenType.DM_Null,
             TokenType.DM_Switch,
+            TokenType.DM_Sleep,
             TokenType.DM_Spawn,
             TokenType.DM_Do,
             TokenType.DM_While,
@@ -802,6 +803,7 @@
                     TokenType.DM_Switch => Switch(),
                     TokenType.DM_Continue => Continue(),
                     TokenType.DM_Break => Break(),
+                    TokenType.DM_Sleep => Sleep(),
                     TokenType.DM_Spawn => Spawn(),
                     TokenType.DM_While => While(),
                     TokenType.DM_Do => DoWhile(),
@@ -1124,6 +1126,23 @@
             return sets[0];
         }
 
+        public DMASTProcStatementSleep? Sleep() {
+            var loc = Current().Location;
+
+            if (Check(TokenType.DM_Sleep)) {
+                Whitespace();
+                bool hasParenthesis = Check(TokenType.DM_LeftParenthesis);
+                Whitespace();
+                DMASTExpression? delay = Expression();
+                RequireExpression(ref delay, "Expected delay to sleep for");
+                if (hasParenthesis) ConsumeRightParenthesis();
+
+                return new DMASTProcStatementSleep(loc, delay ?? new DMASTConstantInteger(loc, 0));
+            } else {
+                return null;
+            }
+        }
+
         private DMASTProcStatementSpawn Spawn() {
             var loc = Current().Location;
             Advance();

DMCompiler/Compiler/Token.cs

@@ -127,6 +127,7 @@ public enum TokenType : byte {
     DM_Set,
     DM_Slash,
     DM_SlashEquals,
+    DM_Sleep,
     DM_Spawn,
     DM_Star,
     DM_StarEquals,

DMCompiler/DM/Builders/DMASTFolder.cs

@@ -91,6 +91,10 @@ public void FoldAst(DMASTNode? ast) {
                     FoldAst(switchCase.Body);
                 }
 
+                break;
+            case DMASTProcStatementSleep statementSleep:
+                statementSleep.Delay = FoldExpression(statementSleep.Delay);
+
                 break;
             case DMASTProcStatementSpawn statementSpawn:
                 statementSpawn.Delay = FoldExpression(statementSpawn.Delay);

DMCompiler/DM/Builders/DMProcBuilder.cs

@@ -3,6 +3,7 @@
 using DMCompiler.Compiler.DM;
 using DMCompiler.Compiler.DM.AST;
 using DMCompiler.DM.Expressions;
+using System.Runtime.InteropServices.Marshalling;
 
 namespace DMCompiler.DM.Builders;
 
@@ -74,6 +75,7 @@
             case DMASTProcStatementLabel statementLabel: ProcessStatementLabel(statementLabel); break;
             case DMASTProcStatementBreak statementBreak: ProcessStatementBreak(statementBreak); break;
             case DMASTProcStatementDel statementDel: ProcessStatementDel(statementDel); break;
+            case DMASTProcStatementSleep statementSleep: ProcessStatementSleep(statementSleep); break;
             case DMASTProcStatementSpawn statementSpawn: ProcessStatementSpawn(statementSpawn); break;
             case DMASTProcStatementReturn statementReturn: ProcessStatementReturn(statementReturn); break;
             case DMASTProcStatementIf statementIf: ProcessStatementIf(statementIf); break;
@@ -142,6 +144,22 @@
         proc.DeleteObject();
     }
 
+    private void ProcessStatementSleep(DMASTProcStatementSleep statementSleep) {
+
+        var expr = _exprBuilder.Create(statementSleep.Delay);
+        if (expr.TryAsConstant(compiler, out var constant)) {
+            if (constant is Number constantNumber) {
+                proc.Sleep(constantNumber.Value);
+                return;
+            }
+
+            constant.EmitPushValue(ExprContext);
+        } else
+            expr.EmitPushValue(ExprContext);
+
+        proc.SleepDelayPushed();
+    }
+
     private void ProcessStatementSpawn(DMASTProcStatementSpawn statementSpawn) {
         _exprBuilder.Emit(statementSpawn.Delay);
 

DMCompiler/DM/DMProc.cs

@@ -672,18 +672,20 @@ public void MarkLoopContinue(string loopLabel) {
         AddLabel($"{loopLabel}_continue");
     }
 
-    public void BackgroundSleep() {
-        // TODO This seems like a bad way to handle background, doesn't it?
+    public void SleepDelayPushed() => WriteOpcode(DreamProcOpcode.Sleep);
+
+    public void Sleep(float delay) {
+        if (delay < 0) // yielding
+            WriteOpcode(DreamProcOpcode.BackgroundSleep);
+        else {
+            PushFloat(delay);
+            WriteOpcode(DreamProcOpcode.Sleep);
+        }
+    }
 
+    public void BackgroundSleep() {
         if ((Attributes & ProcAttributes.Background) == ProcAttributes.Background) {
-            if (!_compiler.DMObjectTree.TryGetGlobalProc("sleep", out var sleepProc)) {
-                _compiler.Emit(WarningCode.ItemDoesntExist, Location, "Cannot do a background sleep without a sleep proc");
-                return;
-            }
-
-            PushFloat(-1); // argument given to sleep()
-            Call(DMReference.CreateGlobalProc(sleepProc.Id), DMCallArgumentsType.FromStack, 1);
-            Pop(); // Pop the result of the sleep call
+            WriteOpcode(DreamProcOpcode.BackgroundSleep);
         }
     }
 

DMCompiler/DMStandard/_Standard.dm

@@ -93,7 +93,6 @@ proc/round(A, B) as num
 proc/sha1(input) as text|null
 proc/shutdown(Addr,Natural = 0)
 proc/sign(A) as num
-proc/sleep(Delay)
 proc/sorttext(T1, T2) as num
 proc/sorttextEx(T1, T2) as num
 proc/sound(file, repeat = 0, wait, channel, volume)