.luarc.json

@@ -6,5 +6,6 @@
     "love.filesystem.load": "loadfile"
   },
   "workspace.ignoreDir": ["dev_utils"],
-  "diagnostics.ignoredFiles": "Disable"
+  "diagnostics.ignoredFiles": "Disable",
+    "completion.autoRequire": false
 }

lib/character/behaviors/sprite.lua

@@ -70,7 +70,7 @@ function sprite:draw()
 end
 
 --- @return Task<nil>
-function sprite:animate(state)
+function sprite:animate(state, node)
     return function(callback)
         if not self.animationGrid[state] then
             print("[SpriteBehavior]: no animation for '" .. state .. "'")

lib/level/grid/base.lua

@@ -8,7 +8,7 @@ grid.__index = grid
 --- adds a value to the grid
 --- @param value any
 function grid:add(value)
-    self.__grid[tostring(value.position)] = value
+    grid[tostring(value.position)] = value
 end
 
 --- @param position Vec3

lib/level/level.lua

@@ -40,7 +40,6 @@ end
 function level:update(dt)
     utils.each(self.deadIds, function(id)
         self.characters[id] = nil
-        self.turnOrder:remove(id)
     end)
     self.deadIds = {}
 

lib/level/turn_order.lua

@@ -117,29 +117,4 @@ function turnOrder:add(id)
     self.actedQueue:insert(id) -- новые персонажи по умолчанию попадают в очередь следующего хода
 end
 
---- Удалить персонажа из очереди хода (например, при смерти)
---- @param id Id
-function turnOrder:remove(id)
-    if self.current == id then
-        self.current = self.pendingQueue:pop()
-        if not self.current then
-            self:endRound()
-        end
-        return
-    end
-
-    local function filterQueue(q, targetId)
-        local newQ = PriorityQueue.new(initiativeComparator)
-        for _, val in ipairs(q.data) do
-            if val ~= targetId then
-                newQ:insert(val)
-            end
-        end
-        return newQ
-    end
-
-    self.actedQueue = filterQueue(self.actedQueue, id)
-    self.pendingQueue = filterQueue(self.pendingQueue, id)
-end
-
 return { new = new }

lib/spellbook.lua

@@ -7,7 +7,7 @@
 --- --TODO: каждый каст должен возвращать объект, который позволит отследить момент завершения анимации спелла
 --- Да, это Future/Promise/await/async
 
-local task    = require 'lib.utils.task'
+local Counter = require 'lib.utils.counter'
 
 --- @class Spell Здесь будет много бойлерплейта, поэтому тоже понадобится спеллмейкерский фреймворк, который просто вернет готовый Spell
 --- @field tag string
@@ -55,7 +55,11 @@ function walk:cast(caster, target)
         return
     end
 
-    return caster:has(Tree.behaviors.tiled):followPath(path)
+    return function(callback)
+        return caster:has(Tree.behaviors.tiled):followPath(path)(
+            callback
+        ) -- <- callback вызовется после followPath
+    end
 end
 
 function walk:update(caster, dt)
@@ -99,10 +103,14 @@ function regenerateMana:cast(caster, target)
         Tree.behaviors.positioned.new(caster:has(Tree.behaviors.positioned).position + Vec3 { 0.5, 0.5 }),
     }
 
-    return task.wait {
-        light:has(Tree.behaviors.light):animateColor(Vec3 {}),
-        sprite:animate("hurt")
-    }
+    return function(callback)
+        light:has(Tree.behaviors.light):animateColor(Vec3 {})(
+            function()
+                light:die()
+            end
+        )
+        sprite:animate("hurt")(callback)
+    end
 end
 
 local attack = setmetatable({}, spell)
@@ -135,16 +143,20 @@ function attack:cast(caster, target)
 
     caster:try(Tree.behaviors.positioned, function(b) b:lookAt(target) end)
 
-    return
-        task.wait {
-            sprite:animate("attack"),
-            task.wait {
-                task.chain(targetCharacter:has(Tree.behaviors.residentsleeper):sleep(200),
-                    function() return targetSprite:animate("hurt") end
-                ),
+    return function(callback)
+        local c = Counter(callback)
+
+        c.push()
+        sprite:animate("attack")(c.pop)
+
+        c.push()
+        targetCharacter:has(Tree.behaviors.residentsleeper):sleep(200)(
+            function()
+                targetSprite:animate("hurt")(c.pop)
                 Tree.audio:play(Tree.assets.files.audio.sounds.hurt)
-            }
-        }
+            end
+        )
+    end
 end
 
 ----------------------------------------

lib/utils/counter.lua

@@ -4,7 +4,6 @@
 --- @field private isAlive boolean
 --- @field push fun():nil добавить 1 к счетчику
 --- @field pop fun():nil убавить 1 у счетчика
---- @field set fun(count: integer): nil установить значение на счетчике
 local counter = {}
 counter.__index = counter
 
@@ -32,7 +31,6 @@ local function new(onFinish)
     }
     t.push = function() counter._push(t) end
     t.pop = function() counter._pop(t) end
-    t.set = function(count) t.count = count end
 
     return setmetatable(t, counter)
 end

lib/utils/task.lua

@@ -34,50 +34,3 @@
 --- ```
 --- @generic T
 --- @alias Task<T> fun(callback: fun(value: T): nil): nil
-
---- Возвращает новый Task, который завершится после завершения всех переданных `tasks`.
----
---- Значение созданного Task будет содержать список значений `tasks` в том же порядке.
----
---- См. также https://api.dart.dev/dart-async/Future/wait.html
---- @generic T
---- @param tasks Task[]
---- @return Task<T[]>
-local function wait(tasks)
-    local count = #tasks
-    local results = {}
-
-    return function(callback)
-        for i, task in ipairs(tasks) do
-            task(
-                function(result)
-                    results[i] = result
-
-                    count = count - 1
-                    if count == 0 then callback(results) end
-                end
-            )
-        end
-    end
-end
-
-
---- Последовательно объединяет два `Task` в один.
---- @generic T
---- @generic R
---- @param task Task<T> `Task`, который выполнится первым
---- @param onCompleted fun(value: T): Task<R> Конструктор второго `Task`. Принимает результат выполнения первого `Task`
---- @return Task<R>
-local function chain(task, onCompleted)
-    return function(callback)
-        task(function(value)
-            local task2 = onCompleted(value)
-            task2(callback)
-        end)
-    end
-end
-
-return {
-    wait = wait,
-    chain = chain
-}

main.lua

@@ -2,8 +2,6 @@
 
 local character = require "lib/character/character"
 local testLayout
-local TestRunner = require "test.runner"
-TestRunner:register(require "test.task")
 
 function love.conf(t)
     t.console = true
@@ -69,8 +67,6 @@ end
 
 local lt = "0"
 function love.update(dt)
-    TestRunner:update(dt) -- закомментировать для отключения тестов
-
     local t1 = love.timer.getTime()
     Tree.controls:poll()
     Tree.level.camera:update(dt) -- сначала логика камеры, потому что на нее завязан UI

test/runner.lua

@@ -1,46 +0,0 @@
---- @class Test
-local test = {}
-function test:run(complete) end
-
-function test:update(dt) end
-
---- @class TestRunner
---- @field private tests Test[]
---- @field private state "loading" | "running" | "completed"
---- @field private completedCount integer
-local runner = {}
-runner.tests = {}
-runner.state = "loading"
-runner.completedCount = 0
-
---- глобальный update для тестов, нужен для тестирования фич, зависимых от времени
-function runner:update(dt)
-    if self.state == "loading" then
-        print("[TestRunner]: running " .. #self.tests .. " tests")
-
-        for _, t in ipairs(self.tests) do
-            t:run(
-                function()
-                    self.completedCount = self.completedCount + 1
-                    if self.completedCount == #self.tests then
-                        self.state = "completed"
-                        print("[TestRunner]: tests completed")
-                    end
-                end
-            )
-        end
-        self.state = "running"
-    end
-
-    for _, t in ipairs(self.tests) do
-        if t.update then t:update(dt) end
-    end
-end
-
---- добавляет тест для прохождения
---- @param t Test
-function runner:register(t)
-    table.insert(self.tests, t)
-end
-
-return runner

test/task.lua

@@ -1,75 +0,0 @@
-local task = require "lib.utils.task"
-
-local test = {}
-
-local t0
-local task1Start, task2Start
-local task1Callback, task2Callback
-
---- @return Task<number>
-local function task1()
-    return function(callback)
-        task1Start = love.timer.getTime()
-        task1Callback = callback
-    end
-end
-
---- @return Task<number>
-local function task2()
-    return function(callback)
-        task2Start = love.timer.getTime()
-        task2Callback = callback
-    end
-end
-
-function test:run(complete)
-    t0 = love.timer.getTime()
-
-    task.wait {
-        task1(),
-        task2()
-    } (function(values)
-            local tWait = love.timer.getTime()
-            local dt = tWait - t0
-
-            local t1 = values[1]
-            local t2 = values[2]
-
-            assert(type(t1) == "number" and type(t2) == "number")
-            assert(t2 > t1)
-            assert(dt >= 2, "dt = " .. dt)
-
-            print("task.wait completed in " .. dt .. " sec", "t1 = " .. t1 - t0, "t2 = " .. t2 - t0)
-
-
-            t0 = love.timer.getTime()
-            task.chain(task1(), function(value)
-                t1 = value
-                assert(t1 - t0 >= 1)
-                return task2()
-            end)(
-                    function(value)
-                        t2 = value
-                        assert(t2 - t0 >= 2)
-                        print("task.chain completed in " .. t2 - t0 .. " sec")
-
-                        complete()
-                    end
-                )
-        end)
-end
-
-function test:update(dt)
-    local t = love.timer.getTime()
-    if task1Start and t - task1Start >= 1 then
-        task1Callback(t)
-        task1Start = nil
-    end
-
-    if task2Start and t - task2Start >= 2 then
-        task2Callback(t)
-        task2Start = nil
-    end
-end
-
-return test